diff options
Diffstat (limited to 'tools/source')
71 files changed, 52531 insertions, 0 deletions
diff --git a/tools/source/communi/geninfo.cxx b/tools/source/communi/geninfo.cxx new file mode 100644 index 000000000000..f817b58b1dc3 --- /dev/null +++ b/tools/source/communi/geninfo.cxx @@ -0,0 +1,469 @@ +/************************************************************************* + * + * $RCSfile: geninfo.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +#include "geninfo.hxx" +#include <stdio.h> + +// +// class GenericInformation +// + +/*****************************************************************************/ +GenericInformation::GenericInformation( const ByteString &rKey, + const ByteString &rValue, + GenericInformationList *pParentList, + GenericInformationList *pSubInfos ) +/*****************************************************************************/ + : ByteString( rKey ), + sValue( rValue ), + pParent( pParentList ), + pInfoList( pSubInfos ) +{ + // if a ParentList exists, insert this object into it + if ( pParent ) + pParent->InsertInfo( this ); + // make myself owner of pInfoList + if ( pInfoList ) + pInfoList->SetOwner( this ); +} + +/*****************************************************************************/ +GenericInformation::GenericInformation( const GenericInformation& rInf, + BOOL bCopySubs) +/*****************************************************************************/ + : ByteString( rInf ), + sValue( rInf.sValue ), + pParent(NULL), + pInfoList( 0L ) +{ + if(bCopySubs && rInf.pInfoList) + pInfoList = new GenericInformationList(*rInf.pInfoList, this); +} + +/*****************************************************************************/ +GenericInformation::~GenericInformation() +/*****************************************************************************/ +{ + // remove pInfoList and all childs out of memory + delete pInfoList; + pInfoList = 0; + + // remove this Info out of ParentList + if ( pParent ) + pParent->RemoveInfo( this ); +} + +/*****************************************************************************/ +BOOL GenericInformation::InsertSubInfo( GenericInformation *pInfo ) +/*****************************************************************************/ +{ + return ( pInfoList && pInfoList->InsertInfo( pInfo )); +} + +/*****************************************************************************/ +BOOL GenericInformation::InsertSubInfo( const ByteString &rPathKey, const ByteString &rValue, + BOOL bSearchByPath, BOOL bNewPath ) +/*****************************************************************************/ +{ + return (pInfoList && pInfoList->InsertInfo( rPathKey, rValue, bSearchByPath, bNewPath )); +} + +/*****************************************************************************/ +void GenericInformation::RemoveSubInfo( GenericInformation *pInfo, + BOOL bDelete ) +/*****************************************************************************/ +{ + pInfoList->RemoveInfo( pInfo, bDelete ); +} + +/*****************************************************************************/ +//void GenericInformation::RemoveSelf( BOOL bDelete ) +/*****************************************************************************/ +/*{ + if ( pParent ) + pParent->RemoveInfo( this, bDelete ); // loescht sich aus der Liste vom Parent und + // bei Bedarf auch mit obiger Methode alle Sublisten + + // loescht sich bei Bedarf auch selbst + if ( bDelete ) + delete this; +} +*/ + +/*****************************************************************************/ +GenericInformation *GenericInformation::GetSubInfo( ByteString &rKey, + BOOL bSearchByPath, + BOOL bCreatePath ) +/*****************************************************************************/ +{ + if ( !pInfoList && bCreatePath ) + pInfoList = new GenericInformationList( this ); + if ( pInfoList ) + return pInfoList->GetInfo( rKey, bSearchByPath, bCreatePath ); + return NULL; +} + + +// +// class GenericInformationList +// + +/*****************************************************************************/ +GenericInformationList::GenericInformationList( GenericInformation *pParent ) +/*****************************************************************************/ + : pOwner( pParent ) +{ +} + +/*****************************************************************************/ +GenericInformationList::GenericInformationList(const GenericInformationList& rList, + GenericInformation *pParent) +/*****************************************************************************/ +{ + USHORT i; + GenericInformation* pTemp,*pWork; + + pOwner = pParent; + + for(i=0;i<rList.Count();i++) + { + pTemp = rList.GetObject(i); + pWork = new GenericInformation(*pTemp,TRUE); + + Insert(pWork,LIST_APPEND); + } +} + +/*****************************************************************************/ +GenericInformationList::~GenericInformationList() +/*****************************************************************************/ +{ + // delete all Informations stored in this List + // ### GH: Hier werden dann wohl etwa die Hälfte der Einträge gelöscht +/* for ( ULONG i = 0; i < Count(); i++ ) { + GetObject( i )->ListDeleted(); + delete GetObject( i ); + Remove( i );*/ + // Neue Variante: + while ( Count() ) { + GetObject( 0 )->ListDeleted(); + delete GetObject( 0 ); + Remove( (ULONG)0 ); + } +} + +/*****************************************************************************/ +GenericInformation *GenericInformationList::Search( ULONG &rPos, ByteString sKey, + ULONG nStart, ULONG nEnd ) +/*****************************************************************************/ +{ + if ( Count() == 0 ) { + rPos = 0; + return NULL; + } + + if ( nStart == nEnd ) { + rPos = nStart; + ByteString sCandidate = ByteString( *GetObject( nStart )); + if ( sCandidate.ToUpperAscii() == sKey.ToUpperAscii()) { + return GetObject( nStart ); // found !!! + } + else { + // requested key not found + return NULL; + } + } + + // search binary in existing list + ULONG nActPos = nStart + (( nEnd - nStart ) / 2 ); + rPos = nActPos; + ByteString sCandidate = ByteString( *GetObject( nActPos )); + + if ( sCandidate.ToUpperAscii() == sKey.ToUpperAscii()) + return GetObject( nActPos ); // found !!! + + // split the list at ActPos + if ( sCandidate < sKey ) + return Search( rPos, sKey, nActPos + 1, nEnd ); + else + return Search( rPos, sKey, nStart, nActPos ); +} + +/*****************************************************************************/ +GenericInformation *GenericInformationList::GetInfo( ByteString &rKey, + BOOL bSearchByPath, + BOOL bCreatePath ) +/*****************************************************************************/ +{ + + rKey.EraseLeadingChars( '/' ); + rKey.EraseTrailingChars( '/' ); + + ByteString sKey; + if ( bSearchByPath ) + sKey = rKey.GetToken( 0, '/' ); + else + sKey = rKey; + + ULONG nPos = 0; + GenericInformation *pReturnInfo = Search( nPos, sKey, 0, Count() - 1 ); + /* wenn kein Searchpath gesetzt und kein Returninfo vorhanden, + * gib NULL zurueck + * wenn Searchpath gesetzt und returninfo vorhanden, + * suche weiter nach unten + * wenn searchpath gesetzt kein returninfo vorhanden und newpath gesetzt, + * mache neues Verzeichniss + */ + USHORT nTokenCount = rKey.GetTokenCount('/'); + // search for next key of path in next level of tree + if ( bSearchByPath && (nTokenCount > 1)) { + ByteString sPath = ByteString(rKey.Copy( sKey.Len() + 1 )); + if ( !pReturnInfo ) { // wenn kein Return, dann muss man es anlegen + if ( !bCreatePath ) // wenn aber kein Create, dann nicht anlegen + return NULL; + USHORT nTmp = 0; + pReturnInfo = new GenericInformation( sKey, "", this, NULL); + pReturnInfo->SetSubList( new GenericInformationList( pReturnInfo )); + } + return pReturnInfo->GetSubInfo( sPath, TRUE, bCreatePath ); + } + if ( !pReturnInfo && bCreatePath ) { + pReturnInfo = new GenericInformation ( sKey, "", this, NULL); + } + + return pReturnInfo; // kann durchaus NULL sein. +} + +/*****************************************************************************/ +ULONG GenericInformationList::InsertSorted( GenericInformation *pInfo, + BOOL bOverwrite, + ULONG nStart, ULONG nEnd ) +/*****************************************************************************/ +{ + if ( Count() == 0 ) { + // empty list, so insert at first pos + Insert( pInfo, LIST_APPEND ); + return 0; + } + +// ### GH: dieser Block schein überflüssig zu sein + ByteString sKey( pInfo->GetBuffer()); + if ( Count() == 1 ) { + ByteString sCandidate( *GetObject( 0 )); + if ( sCandidate.ToUpperAscii() == sKey.ToUpperAscii()) { + // key allready exists in list + if ( bOverwrite ) + Replace( pInfo, ULONG(0)); // ### Laut NF scheint hier ein Memory Leak zu sein + return 0; + } + else if ( sCandidate > sKey ) { + Insert( pInfo, ULONG(0)); + return 0; + } + else { + Insert( pInfo, LIST_APPEND ); + return 1; + } + } +// ### GH: /ENDE/ dieser Block schein überflüssig zu sein + + ULONG nActPos = nStart + (( nEnd - nStart ) / 2 ); + ByteString sCandidate = ByteString( *GetObject( nActPos )); + + if ( sCandidate.ToUpperAscii() == sKey.ToUpperAscii()) { + // key allready exists in list + if ( bOverwrite ) + Replace( pInfo, nActPos ); // ### Laut NF scheint hier ein Memory Leak zu sein + return nActPos; + } + + if ( nStart == nEnd ) { + // now more ways to search for key -> insert here + if ( sCandidate > sKey ) { + Insert( pInfo, nStart ); + return nStart; + } + else { + Insert( pInfo, nStart + 1 ); + return ( nStart + 1 ); + } + } + + if ( nActPos == Count() - 1 ) { + // reached end of list -> insert here + Insert( pInfo, LIST_APPEND ); + return ( nActPos + 1 ); + } + + ByteString sSecondCand = ByteString( *GetObject( nActPos + 1 )); + if (( sCandidate < sKey ) && ( sSecondCand.ToUpperAscii() > sKey )) { + // optimal position to insert object + Insert( pInfo, nActPos + 1 ); + return ( nActPos + 1 ); + } + + if ( sCandidate < sKey ) + return InsertSorted( pInfo, bOverwrite, nActPos + 1, nEnd ); + else + return InsertSorted( pInfo, bOverwrite, nStart, nActPos ); +} + +/*****************************************************************************/ +BOOL GenericInformationList::InsertInfo( GenericInformation *pInfo, + BOOL bOverwrite ) +/*****************************************************************************/ +{ + if ( !pInfo->Len()) + return FALSE; + + InsertSorted( pInfo, bOverwrite, 0, Count() - 1 ); + return TRUE; +} + + +/*****************************************************************************/ +BOOL GenericInformationList::InsertInfo( const ByteString &rPathKey, const ByteString &rValue, + BOOL bSearchByPath, BOOL bNewPath ) +/*****************************************************************************/ +{ + GenericInformation *pInfo; + ByteString sPathKey ( rPathKey ); + sPathKey.EraseLeadingChars( '/' ); + sPathKey.EraseTrailingChars( '/' ); + + pInfo = GetInfo( sPathKey, bSearchByPath, bNewPath ); + + if ( pInfo ) { + pInfo->SetValue( rValue ); + return TRUE; + } + return FALSE; +} + +/***************************************************************************** +BOOL GenericInformationList::InsertInfo( const String &rPathKey, + const String &rValue, + BOOL bNewPath = FALSE) +/***************************************************************************** +{ + GenericInformation *pInfo; + + if ( !pPathKey || '\0'==pPathKey[0] ) + return FALSE; + + char *pNextItem = strchr( pPathKey, '/' ); + if ( !pNextItem ) { // kein Token mehr gefunden + /* aus dem PathKey kann nun eine GenericInformation gebildet + * und eingefuegt werden * + pInfo = GetInfo( pPathKey, FALSE ); + // Object besteht nicht und soll auch nicht nachgebildet werden + if ( !pInfo && !bNewPath ) + return FALSE; + // erzeuge neue GI und stopfe sie in die Liste. Fertig ! + pInfo = new GenericInformation( String( pPathKey ), String( pValue ), 0, 0 ); + return InsertInfo( pInfo, TRUE ); + } + else { // noch nicht fertig, muss noch tiefer in den Baum gehen + // SuchString anfertigen + String sSearch ( pPathKey ); + sSearch.Erase ( USHORT(pNextItem - pPathKey)); + // suchen.. + pInfo = GetInfo( sSearch, FALSE ); + if ( !pInfo && ! bNewPath) // subinfo nicht vorhanden und + return FALSE; // ich darf keinen neuen Pfad anlegen + + if ( !pInfo ) + // neue Subinfo machen und einfuegen + pInfo = new GenericInformation ( sSearch , "", this, 0 ); + + pNextItem++; + return pInfo->InsertSubInfo( pNextItem, pValue, bNewPath ); + } + } +} +*/ + +/*****************************************************************************/ +void GenericInformationList::RemoveInfo( GenericInformation *pInfo, + BOOL bDelete ) +/*****************************************************************************/ +{ + Remove( pInfo ); + if ( bDelete ) + delete pInfo; + if ( Count() == 0 && pOwner ) // Leere Listen entfernen; + { + SetOwner( NULL ); + delete this; + } +} + +GenericInformation* GenericInformationList::SetOwner( GenericInformation *pNewOwner ) +{ + GenericInformation *pOldOwner = pOwner; + if ( pOwner ) // bei parent austragen; + pOwner->SetSubList( NULL ); + if ( pNewOwner ) + pNewOwner->SetSubList( this ); + pOwner = pNewOwner; + return pOldOwner; +} + + diff --git a/tools/source/communi/makefile.mk b/tools/source/communi/makefile.mk new file mode 100644 index 000000000000..970f41a6121a --- /dev/null +++ b/tools/source/communi/makefile.mk @@ -0,0 +1,102 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=TOOLS +TARGET=communi + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +CXXFILES= simplecm.cxx bcst.cxx + +OBJFILES= $(OBJ)$/simplecm.obj \ + $(OBJ)$/bcst.obj \ + $(OBJ)$/persbcst.obj \ + $(OBJ)$/iiclient.obj \ + $(OBJ)$/siclient.obj \ + $(OBJ)$/infocom.obj \ + $(OBJ)$/bsockcon.obj \ + $(OBJ)$/ssockcon.obj \ + $(OBJ)$/parser.obj \ + $(OBJ)$/geninfo.obj \ + +SLOFILES= $(SLO)$/simplecm.obj \ + $(SLO)$/bcst.obj \ + $(SLO)$/persbcst.obj \ + $(SLO)$/iiclient.obj \ + $(SLO)$/siclient.obj \ + $(SLO)$/infocom.obj \ + $(SLO)$/bsockcon.obj \ + $(SLO)$/ssockcon.obj \ + $(SLO)$/parser.obj \ + $(SLO)$/geninfo.obj \ + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/communi/parser.cxx b/tools/source/communi/parser.cxx new file mode 100644 index 000000000000..99160560504a --- /dev/null +++ b/tools/source/communi/parser.cxx @@ -0,0 +1,438 @@ +/************************************************************************* + * + * $RCSfile: parser.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdio.h> +#include <stream.hxx> +#include <fsys.hxx> + +#include "iparser.hxx" +#include "geninfo.hxx" + + + +// +// class InformationParser +// + +const char InformationParser::cKeyLevelChars = '\t'; + +/*****************************************************************************/ +InformationParser::InformationParser( BOOL bReplace ) +/*****************************************************************************/ + : pActStream( NULL ), + nErrorCode( 0 ), + nErrorLine( 0 ), + nActLine( 0 ), + bRecover( FALSE ), + sOldLine( "" ), + sErrorText( "" ), + bReplaceVariables( bReplace ), + nLevel( 0 ), + sUPD( "" ), + sVersion( "" ) +{ +} + +/*****************************************************************************/ +InformationParser::~InformationParser() +/*****************************************************************************/ +{ +} + +/*****************************************************************************/ +ByteString &InformationParser::ReadLine() +/*****************************************************************************/ +{ + ByteString sLine; + if ( bRecover ) { + bRecover = FALSE; + } + else { + pActStream->ReadLine( sLine ); + sLine.EraseLeadingChars( 0x09 ); + sLine.EraseLeadingChars( ' ' ); + + if ( bReplaceVariables ) { + while( sLine.SearchAndReplace( "%UPD", sUPD ) != (USHORT)-1 ); + while( sLine.SearchAndReplace( "%VERSION", sVersion ) != (USHORT)-1 ); + } + + sOldLine = sLine; + nActLine++; + } + + return sOldLine; +} + +/*****************************************************************************/ +GenericInformation *InformationParser::ReadKey( + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + // this method has no error handling yet, but it works very fast. + // it is used to create whole informations and sub informations in + // a simple data format in memory, readed in a configuration file with + // following format: + + /* + + key [value] + { + key [value] + key [value] + { + key [value] + ... + ... + } + } + key [value] + ... + ... + + */ + + GenericInformation *pInfo = NULL; + + ByteString sLine( ReadLine()); + ByteString sKey( "" ); + ByteString sValue( "" ); + + // key separated from value by tab? + USHORT nWSPos = sLine.Search( ' ' ); + if ( sLine.Search( '\t' ) < nWSPos ) { + nWSPos = sLine.Search( '\t' ); + sLine.SearchAndReplace( "\t", " " ); + } + + if ( sLine.GetTokenCount( ' ' ) > 1 ) { + sKey = sLine.GetToken( 0, ' ' ); + sValue = sLine.Copy( sKey.Len() + 1 ); + while (( sValue.Search( ' ' ) == 0 ) || ( sValue.Search( '\t' ) == 0 )) { + sValue.Erase( 0, 1 ); + } + } + else + sKey=sLine; + + if ( bReplaceVariables && !nLevel ) { + sUPD = sKey.Copy( sKey.Len() - 3 ); + sVersion = sKey; + } + + if ( ReadLine() == "{" ) { + nLevel++; + GenericInformationList *pSubList = new GenericInformationList(); + while ( ReadLine() != "}" ) { + Recover(); + ReadKey( pSubList ); + } + nLevel--; + pInfo = new GenericInformation( sKey, sValue, + pExistingList, pSubList ); + } + else { + Recover(); + pInfo = new GenericInformation( sKey, sValue, pExistingList ); + } + + return pInfo; +} + +/*****************************************************************************/ +void InformationParser::Recover() +/*****************************************************************************/ +{ + bRecover = TRUE; +} + +/*****************************************************************************/ +BOOL InformationParser::Save( SvStream &rOutStream, + const GenericInformationList *pSaveList, + USHORT nLevel ) +/*****************************************************************************/ +{ + USHORT i; + ULONG nInfoListCount; + ByteString sTmpStr; + GenericInformation *pGenericInfo; + GenericInformationList *pGenericInfoList; + + for ( nInfoListCount = 0; nInfoListCount < pSaveList->Count(); nInfoListCount++) { + // Key-Value Paare schreiben + pGenericInfo = pSaveList->GetObject( nInfoListCount ); + sTmpStr = ""; + for( i=0; i<nLevel; i++) + sTmpStr += cKeyLevelChars; + sTmpStr += pGenericInfo->GetBuffer(); + sTmpStr += ' '; + sTmpStr += pGenericInfo->GetValue(); + if ( !rOutStream.WriteLine( sTmpStr ) ) + return FALSE; + + // wenn vorhanden, bearbeite recursive die Sublisten + if (( pGenericInfoList = pGenericInfo->GetSubList() ) != 0) { + // oeffnende Klammer + sTmpStr = ""; + for( i=0; i<nLevel; i++) + sTmpStr += cKeyLevelChars; + sTmpStr += '{'; + if ( !rOutStream.WriteLine( sTmpStr ) ) + return FALSE; + // recursiv die sublist abarbeiten + if ( !Save( rOutStream, pGenericInfoList, nLevel+1 ) ) + return FALSE; + // schliessende Klammer + sTmpStr = ""; + for( i=0; i<nLevel; i++) + sTmpStr += cKeyLevelChars; + sTmpStr += '}'; + if ( !rOutStream.WriteLine( sTmpStr ) ) + return FALSE; + } + } + return TRUE; +} + +/*****************************************************************************/ +GenericInformationList *InformationParser::Execute( + SvStream &rSourceStream, + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + GenericInformationList *pList; + if ( pExistingList ) + pList = pExistingList; + else + pList = new GenericInformationList(); + + pActStream = &rSourceStream; + + // read all infos out of current file + while( !rSourceStream.IsEof()) { + nLevel = 0; + ReadKey( pList ); + } + + return pList; +} + +/*****************************************************************************/ +GenericInformationList *InformationParser::Execute( SvMemoryStream &rSourceStream, + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + sStreamName = UniString( "Memory", gsl_getSystemTextEncoding()); + return Execute( (SvStream &)rSourceStream, pExistingList ); +} + +/*****************************************************************************/ +GenericInformationList *InformationParser::Execute( + SvFileStream &rSourceStream, + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + if ( !rSourceStream.IsOpen()) + return NULL; + sStreamName = rSourceStream.GetFileName(); + return Execute( (SvStream &)rSourceStream, pExistingList ); +} + +/*****************************************************************************/ +GenericInformationList *InformationParser::Execute( UniString &rSourceFile, + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + DirEntry aDirEntry( rSourceFile ); + if ( !aDirEntry.Exists()) + return NULL; + + GenericInformationList *pList; + if ( pExistingList ) + pList = pExistingList; + else + pList = new GenericInformationList(); + + // reset status + nErrorCode = 0; + nErrorLine = 0; + nActLine = 0; + + SvFileStream aActStream; + aActStream.Open( rSourceFile, STREAM_READ ); + if( aActStream.GetError()) + return NULL; + + pActStream = &aActStream; + if ( !Execute( aActStream, pList )) { + delete pList; + pList = NULL; + } + + // close the stream + aActStream.Close(); + pActStream = NULL; + + if ( !nErrorCode ) + return pList; + + return NULL; +} + +/*****************************************************************************/ +GenericInformationList *InformationParser::Execute( Dir &rDir, + GenericInformationList *pExistingList ) +/*****************************************************************************/ +{ + GenericInformationList *pList; + + if ( pExistingList ) + pList = pExistingList; + else + pList = new GenericInformationList(); + + for ( USHORT i = 0; i < rDir.Count(); i++ ) { + + // execute this dir + UniString sNextFile( rDir[i].GetFull()); + GenericInformationList *pSubList = Execute( sNextFile ); + + if ( !pSubList ) { + // any errors ? + delete pList; + return NULL; + } + + // create new info and insert it into list + ByteString sFileKey( rDir[i].GetName(), RTL_TEXTENCODING_UTF8 ); + GenericInformation *pInfo = new GenericInformation( + sFileKey, + ByteString( "" ), + pList, pSubList ); + } + + return pList; +} + +/*****************************************************************************/ +BOOL InformationParser::Save( SvFileStream &rSourceStream, + const GenericInformationList *pSaveList ) +/*****************************************************************************/ +{ + if ( !rSourceStream.IsOpen() || !Save( (SvStream &)rSourceStream, pSaveList, 0 )) + return FALSE; + + return TRUE; +} + +/*****************************************************************************/ +BOOL InformationParser::Save( SvMemoryStream &rSourceStream, + const GenericInformationList *pSaveList ) +/*****************************************************************************/ +{ + return Save( (SvStream &)rSourceStream, pSaveList, 0 ); +} + +/*****************************************************************************/ +BOOL InformationParser::Save( const UniString &rSourceFile, + const GenericInformationList *pSaveList ) +/*****************************************************************************/ +{ + SvFileStream *pOutFile = new SvFileStream( rSourceFile, STREAM_STD_WRITE | STREAM_TRUNC ); + + if ( !Save( *pOutFile, pSaveList )) { + delete pOutFile; + return FALSE; + } + delete pOutFile; + return TRUE; +} + +/*****************************************************************************/ +USHORT InformationParser::GetErrorCode() +/*****************************************************************************/ +{ + return nErrorCode; +} + +/*****************************************************************************/ +ByteString &InformationParser::GetErrorText() +/*****************************************************************************/ +{ + // sErrorText = pActStream->GetFileName(); + sErrorText = ByteString( sStreamName, gsl_getSystemTextEncoding()); + sErrorText += ByteString( " (" ); + sErrorText += ByteString( nErrorLine ); + sErrorText += ByteString( "): " ); + + switch ( nErrorCode ) { + case IP_NO_ERROR: + sErrorText += ByteString( "Keine Fehler aufgetereten" ); + break; + case IP_UNEXPECTED_EOF: + sErrorText += ByteString( "Ungültiges Dateiende!" ); + break; + } + + return sErrorText; +} + + diff --git a/tools/source/datetime/datetime.cxx b/tools/source/datetime/datetime.cxx new file mode 100644 index 000000000000..e3cf4a8895fe --- /dev/null +++ b/tools/source/datetime/datetime.cxx @@ -0,0 +1,349 @@ +/************************************************************************* + * + * $RCSfile: datetime.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <datetime.hxx> + +/************************************************************************* +|* +|* DateTime::IsBetween() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 18.05.92 +|* Letzte Aenderung TH 18.05.92 +|* +*************************************************************************/ + +BOOL DateTime::IsBetween( const DateTime& rFrom, + const DateTime& rTo ) const +{ + if ( (*this >= rFrom) && (*this <= rTo) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* DateTime::operator >() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 18.05.92 +|* Letzte Aenderung TH 18.05.92 +|* +*************************************************************************/ + +BOOL DateTime::operator >( const DateTime& rDateTime ) const +{ + if ( (Date::operator>( rDateTime )) || + (Date::operator==( rDateTime ) && Time::operator>( rDateTime )) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* DateTime::operator <() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 18.05.92 +|* Letzte Aenderung TH 18.05.92 +|* +*************************************************************************/ + +BOOL DateTime::operator <( const DateTime& rDateTime ) const +{ + if ( (Date::operator<( rDateTime )) || + (Date::operator==( rDateTime ) && Time::operator<( rDateTime )) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* DateTime::operator >=() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 18.05.92 +|* Letzte Aenderung TH 18.05.92 +|* +*************************************************************************/ + +BOOL DateTime::operator >=( const DateTime& rDateTime ) const +{ + if ( (Date::operator>( rDateTime )) || + (Date::operator==( rDateTime ) && Time::operator>=( rDateTime )) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* DateTime::operator <=() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 18.05.92 +|* Letzte Aenderung TH 18.05.92 +|* +*************************************************************************/ + +BOOL DateTime::operator <=( const DateTime& rDateTime ) const +{ + if ( (Date::operator<( rDateTime )) || + (Date::operator==( rDateTime ) && Time::operator<=( rDateTime )) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* DateTime::GetSecFromDateTime() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +ULONG DateTime::GetSecFromDateTime( const Date& rDate ) const +{ + if ( Date::operator<( rDate ) ) + return 0; + else + { + ULONG nSec = *this-rDate; + nSec *= 24UL*60*60; + long nHour = GetHour(); + long nMin = GetMin(); + nSec += (nHour*3600)+(nMin*60)+GetSec(); + return nSec; + } +} + +/************************************************************************* +|* +|* DateTime::GetSecFromDateTime() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +void DateTime::MakeDateTimeFromSec( const Date& rDate, ULONG nSec ) +{ + long nDays = nSec / (24UL*60*60); + ((Date*)this)->operator=( rDate ); + nSec -= nDays * (24UL*60*60); + USHORT nMin = nSec / 60; + nSec -= nMin * 60; + ((Time*)this)->operator=( Time( 0, nMin, (USHORT)nSec ) ); + operator+=( nDays ); +} + +/************************************************************************* +|* +|* DateTime::operator +=() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime& DateTime::operator +=( const Time& rTime ) +{ + Time aTime = *this; + aTime += rTime; + USHORT nHours = aTime.GetHour(); + if ( aTime.GetTime() > 0 ) + { + while ( nHours >= 24 ) + { + Date::operator++(); + nHours -= 24; + } + aTime.SetHour( nHours ); + } + else if ( aTime.GetTime() != 0 ) + { + while ( nHours >= 24 ) + { + Date::operator--(); + nHours -= 24; + } + Date::operator--(); + aTime = Time( 24, 0, 0 )+aTime; + } + Time::operator=( aTime ); + + return *this; +} + +/************************************************************************* +|* +|* DateTime::operator -=() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime& DateTime::operator -=( const Time& rTime ) +{ + Time aTime = *this; + aTime -= rTime; + USHORT nHours = aTime.GetHour(); + if ( aTime.GetTime() > 0 ) + { + while ( nHours >= 24 ) + { + Date::operator++(); + nHours -= 24; + } + aTime.SetHour( nHours ); + } + else if ( aTime.GetTime() != 0 ) + { + while ( nHours >= 24 ) + { + Date::operator--(); + nHours -= 24; + } + Date::operator--(); + aTime = Time( 24, 0, 0 )+aTime; + } + Time::operator=( aTime ); + + return *this; +} + +/************************************************************************* +|* +|* DateTime::operator+() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime operator +( const DateTime& rDateTime, long nDays ) +{ + DateTime aDateTime( rDateTime ); + aDateTime += nDays; + return aDateTime; +} + +/************************************************************************* +|* +|* DateTime::operator-() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime operator -( const DateTime& rDateTime, long nDays ) +{ + DateTime aDateTime( rDateTime ); + aDateTime -= nDays; + return aDateTime; +} + +/************************************************************************* +|* +|* DateTime::operator+() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime operator +( const DateTime& rDateTime, const Time& rTime ) +{ + DateTime aDateTime( rDateTime ); + aDateTime += rTime; + return aDateTime; +} + +/************************************************************************* +|* +|* DateTime::operator-() +|* +|* Beschreibung DATETIME.SDW +|* Ersterstellung TH 02.10.96 +|* Letzte Aenderung TH 02.10.96 +|* +*************************************************************************/ + +DateTime operator -( const DateTime& rDateTime, const Time& rTime ) +{ + DateTime aDateTime( rDateTime ); + aDateTime -= rTime; + return aDateTime; +} diff --git a/tools/source/datetime/makefile.mk b/tools/source/datetime/makefile.mk new file mode 100644 index 000000000000..5a53e0a0039f --- /dev/null +++ b/tools/source/datetime/makefile.mk @@ -0,0 +1,88 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=datetime + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/tdate.obj \ + $(SLO)$/ttime.obj \ + $(SLO)$/datetime.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/tdate.obj \ + $(OBJ)$/ttime.obj \ + $(OBJ)$/datetime.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/datetime/tdate.cxx b/tools/source/datetime/tdate.cxx new file mode 100644 index 000000000000..72c188944096 --- /dev/null +++ b/tools/source/datetime/tdate.cxx @@ -0,0 +1,540 @@ +/************************************************************************* + * + * $RCSfile: tdate.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#if defined( OS2 ) +#include <svpm.h> +#elif defined( WNT ) +#include <svwin.h> +#elif defined( WIN ) || defined( DOS ) +#include <dos.h> +#elif defined( MAC ) +#include "mac_start.h" +#ifndef __OSUTILS__ +#include "OSUtils.h" +#endif +#include "mac_end.h" +#else +#include <time.h> +#endif + +#include <debug.hxx> +#include <date.hxx> +#ifdef MACOSX +extern "C" { +struct tm *localtime_r(const time_t *timep, struct tm *buffer); +} +#endif + +// ======================================================================= + +static USHORT aDaysInMonth[12] = { 31, 28, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31 }; + +#define MAX_DAYS 3636532 + +// ======================================================================= + +inline BOOL ImpIsLeapYear( USHORT nYear ) +{ + return (((nYear % 4) == 0) && ((nYear % 100) != 0) || ((nYear % 400) == 0)); +} + +// ----------------------------------------------------------------------- + +inline USHORT DaysInMonth( USHORT nMonth, USHORT nYear ) +{ + if ( nMonth != 2 ) + return aDaysInMonth[nMonth-1]; + else + { + if ( ((nYear % 4) == 0) && ((nYear % 100) != 0) || + ((nYear % 400) == 0) ) + return aDaysInMonth[nMonth-1] + 1; + else + return aDaysInMonth[nMonth-1]; + } +} + +// ----------------------------------------------------------------------- + +static long DateToDays( USHORT nDay, USHORT nMonth, USHORT nYear ) +{ + long nDays; + + nDays = ((ULONG)nYear-1) * 365; + nDays += ((nYear-1) / 4) - ((nYear-1) / 100) + ((nYear-1) / 400); + for( USHORT i = 1; i < nMonth; i++ ) + nDays += DaysInMonth(i,nYear); + nDays += nDay; + return nDays; +} + +// ----------------------------------------------------------------------- + +static void DaysToDate( long nDays, + USHORT& rDay, USHORT& rMonth, USHORT& rYear ) +{ + long nTempDays; + long i = 0; + BOOL bCalc; + + do + { + nTempDays = (long)nDays; + rYear = (USHORT)((nTempDays / 365) - i); + nTempDays -= ((ULONG)rYear-1) * 365; + nTempDays -= ((rYear-1) / 4) - ((rYear-1) / 100) + ((rYear-1) / 400); + bCalc = FALSE; + if ( nTempDays < 1 ) + { + i++; + bCalc = TRUE; + } + else + { + if ( nTempDays > 365 ) + { + if ( (nTempDays != 366) || !ImpIsLeapYear( rYear ) ) + { + i--; + bCalc = TRUE; + } + } + } + } + while ( bCalc ); + + rMonth = 1; + while ( (ULONG)nTempDays > DaysInMonth( rMonth, rYear ) ) + { + nTempDays -= DaysInMonth( rMonth, rYear ); + rMonth++; + } + rDay = (USHORT)nTempDays; +} + +// ======================================================================= + +Date::Date() +{ +#if defined( OS2 ) + DATETIME aDateTime; + DosGetDateTime( &aDateTime ); + + // Datum zusammenbauen + nDate = ((ULONG)aDateTime.day) + + (((ULONG)aDateTime.month)*100) + + (((ULONG)aDateTime.year)*10000); +#elif defined( WNT ) + SYSTEMTIME aDateTime; + GetLocalTime( &aDateTime ); + + // Datum zusammenbauen + nDate = ((ULONG)aDateTime.wDay) + + (((ULONG)aDateTime.wMonth)*100) + + (((ULONG)aDateTime.wYear)*10000); +#elif ( defined( WIN ) || defined( DOS )) && !defined( BLC ) + _dosdate_t aDate; + _dos_getdate( &aDate ); + + // Datum zusammenbauen + nDate = ((ULONG)aDate.day) + + (((ULONG)aDate.month)*100) + + (((ULONG)aDate.year)*10000); +#elif ( defined( WIN ) || defined( DOS )) && defined( BLC ) + dosdate_t aDate; + _dos_getdate( &aDate ); + + // Datum zusammenbauen + nDate = ((ULONG)aDate.day) + + (((ULONG)aDate.month)*100) + + (((ULONG)aDate.year)*10000); +#elif defined( MAC ) + DateTimeRec dt; + ::GetTime(&dt); + nDate = ((ULONG)dt.day) + + (((ULONG)dt.month)*100) + + (((ULONG)dt.year )*10000); +#else + time_t nTmpTime; + struct tm aTime; + + // Zeit ermitteln + nTmpTime = time( 0 ); + + // Datum zusammenbauen + if ( localtime_r( &nTmpTime, &aTime ) ) + { + nDate = ((ULONG)aTime.tm_mday) + + (((ULONG)(aTime.tm_mon+1))*100) + + (((ULONG)(aTime.tm_year+1900))*10000); + } + else + nDate = 1 + 100 + (((ULONG)1900)*10000); +#endif +} + +// ----------------------------------------------------------------------- + +void Date::SetDay( USHORT nNewDay ) +{ + ULONG nMonth = GetMonth(); + ULONG nYear = GetYear(); + + nDate = ((ULONG)(nNewDay%100)) + (nMonth*100) + (nYear*10000); +} + +// ----------------------------------------------------------------------- + +void Date::SetMonth( USHORT nNewMonth ) +{ + ULONG nDay = GetDay(); + ULONG nYear = GetYear(); + + nDate = nDay + (((ULONG)(nNewMonth%100))*100) + (nYear*10000); +} + +// ----------------------------------------------------------------------- + +void Date::SetYear( USHORT nNewYear ) +{ + ULONG nDay = GetDay(); + ULONG nMonth = GetMonth(); + + nDate = nDay + (nMonth*100) + (((ULONG)(nNewYear%10000))*10000); +} + +// ----------------------------------------------------------------------- + +DayOfWeek Date::GetDayOfWeek() const +{ + return (DayOfWeek)((ULONG)(DateToDays( GetDay(), GetMonth(), GetYear() )-1) % 7); +} + +// ----------------------------------------------------------------------- + +USHORT Date::GetDayOfYear() const +{ + USHORT nDay = GetDay(); + for( USHORT i = 1; i < GetMonth(); i++ ) + nDay += ::DaysInMonth( i, GetYear() ); + return nDay; +} + +// ----------------------------------------------------------------------- + +USHORT Date::GetWeekOfYear( DayOfWeek eStartDay, + WeekCountStart eWeekStart ) const +{ + short nWeek; + short n1WDay = (short)Date( 1, 1, GetYear() ).GetDayOfWeek(); + short nDayOfYear = (short)GetDayOfYear(); + + // Wochentage beginnen bei 0, deshalb einen abziehen + nDayOfYear--; + // StartDay beruecksichtigen + n1WDay = (n1WDay+(7-(short)eStartDay)) % 7; + + if ( eWeekStart == WEEKCOUNT_FIRSTDAY ) + { + nWeek = ((n1WDay+nDayOfYear)/7) + 1; + // 53te-Woche nur dann, wenn wir nicht schon in der ersten + // Woche des neuen Jahres liegen + if ( nWeek == 54 ) + nWeek = 1; + else if ( nWeek == 53 ) + { + short nDaysInYear = (short)GetDaysInYear(); + short nDaysNextYear = (short)Date( 1, 1, GetYear()+1 ).GetDayOfWeek(); + nDaysNextYear = (nDaysNextYear+(7-(short)eStartDay)) % 7; + if ( nDayOfYear > (nDaysInYear-nDaysNextYear-1) ) + nWeek = 1; + } + } + else if ( eWeekStart == WEEKCOUNT_FIRSTFULLWEEK ) + { + nWeek = ((n1WDay+nDayOfYear)/7); + // Erste Woche eines Jahres entspricht der letzen Woche des + // vorherigen Jahres + if ( nWeek == 0 ) + { + Date aLastDatePrevYear( 31, 12, GetYear()-1 ); + nWeek = aLastDatePrevYear.GetWeekOfYear( eStartDay, eWeekStart ); + } + } + else // ( eWeekStart == WEEKCOUNT_FIRST4DAYWEEK ) + { + // x_monday - thursday + if ( n1WDay < 4 ) + nWeek = 1; + // friday + else if ( n1WDay == 4 ) + nWeek = 53; + // saturday + else if ( n1WDay == 5 ) + { + // Jahr nach Schaltjahr + if ( Date( 1, 1, GetYear()-1 ).IsLeapYear() ) + nWeek = 53; + else + nWeek = 52; + } + // sunday + else + nWeek = 52; + + if ( (nWeek == 1) || (nDayOfYear + n1WDay > 6) ) + { + if ( nWeek == 1 ) + nWeek += (nDayOfYear + n1WDay) / 7; + else + nWeek = (nDayOfYear + n1WDay) / 7; + if ( nWeek == 53 ) + { + // naechster x_Sonntag == erster x_Sonntag im neuen Jahr + // == noch gleiche Woche + long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() ); + nTempDays += 6 - (GetDayOfWeek()+(7-(short)eStartDay)) % 7; + USHORT nDay; + USHORT nMonth; + USHORT nYear; + DaysToDate( nTempDays, nDay, nMonth, nYear ); + nWeek = Date( nDay, nMonth, nYear ).GetWeekOfYear( eStartDay, eWeekStart ); + } + } + } + + return (USHORT)nWeek; +} + +// ----------------------------------------------------------------------- + +USHORT Date::GetDaysInMonth() const +{ + return DaysInMonth( GetMonth(), GetYear() ); +} + +// ----------------------------------------------------------------------- + +BOOL Date::IsLeapYear() const +{ + USHORT nYear = GetYear(); + return ImpIsLeapYear( nYear ); +} + +// ----------------------------------------------------------------------- + +BOOL Date::IsValid() const +{ + USHORT nDay = GetDay(); + USHORT nMonth = GetMonth(); + USHORT nYear = GetYear(); + + if ( !nMonth || (nMonth > 12) ) + return FALSE; + if ( !nDay || (nDay > DaysInMonth( nMonth, nYear )) ) + return FALSE; + else if ( nYear <= 1582 ) + { + if ( nYear < 1582 ) + return FALSE; + else if ( nMonth < 10 ) + return FALSE; + else if ( (nMonth == 10) && (nDay < 15) ) + return FALSE; + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +Date& Date::operator +=( long nDays ) +{ + USHORT nDay; + USHORT nMonth; + USHORT nYear; + long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() ); + + nTempDays += nDays; + if ( nTempDays > MAX_DAYS ) + nDate = 31 + (12*100) + (((ULONG)9999)*10000); + else if ( nTempDays <= 0 ) + nDate = 1 + 100; + else + { + DaysToDate( nTempDays, nDay, nMonth, nYear ); + nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000); + } + + return *this; +} + +// ----------------------------------------------------------------------- + +Date& Date::operator -=( long nDays ) +{ + USHORT nDay; + USHORT nMonth; + USHORT nYear; + long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() ); + + nTempDays -= nDays; + if ( nTempDays > MAX_DAYS ) + nDate = 31 + (12*100) + (((ULONG)9999)*10000); + else if ( nTempDays <= 0 ) + nDate = 1 + 100; + else + { + DaysToDate( nTempDays, nDay, nMonth, nYear ); + nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000); + } + + return *this; +} + +// ----------------------------------------------------------------------- + +Date& Date::operator ++() +{ + USHORT nDay; + USHORT nMonth; + USHORT nYear; + long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() ); + + if ( nTempDays < MAX_DAYS ) + { + nTempDays++; + DaysToDate( nTempDays, nDay, nMonth, nYear ); + nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000); + } + + return *this; +} + +// ----------------------------------------------------------------------- + +Date& Date::operator --() +{ + USHORT nDay; + USHORT nMonth; + USHORT nYear; + long nTempDays = DateToDays( GetDay(), GetMonth(), GetYear() ); + + if ( nTempDays > 1 ) + { + nTempDays--; + DaysToDate( nTempDays, nDay, nMonth, nYear ); + nDate = ((ULONG)nDay) + (((ULONG)nMonth)*100) + (((ULONG)nYear)*10000); + } + return *this; +} + +#ifndef MPW33 + +// ----------------------------------------------------------------------- + +Date Date::operator ++( int ) +{ + Date aOldDate = *this; + Date::operator++(); + return aOldDate; +} + +// ----------------------------------------------------------------------- + +Date Date::operator --( int ) +{ + Date aOldDate = *this; + Date::operator--(); + return aOldDate; +} + +#endif + +// ----------------------------------------------------------------------- + +Date operator +( const Date& rDate, long nDays ) +{ + Date aDate( rDate ); + aDate += nDays; + return aDate; +} + +// ----------------------------------------------------------------------- + +Date operator -( const Date& rDate, long nDays ) +{ + Date aDate( rDate ); + aDate -= nDays; + return aDate; +} + +// ----------------------------------------------------------------------- + +long operator -( const Date& rDate1, const Date& rDate2 ) +{ + ULONG nTempDays1 = DateToDays( rDate1.GetDay(), rDate1.GetMonth(), + rDate1.GetYear() ); + ULONG nTempDays2 = DateToDays( rDate2.GetDay(), rDate2.GetMonth(), + rDate2.GetYear() ); + return nTempDays1 - nTempDays2; +} diff --git a/tools/source/datetime/ttime.cxx b/tools/source/datetime/ttime.cxx new file mode 100644 index 000000000000..af1f2ef267e1 --- /dev/null +++ b/tools/source/datetime/ttime.cxx @@ -0,0 +1,531 @@ +/************************************************************************* + * + * $RCSfile: ttime.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _TOOLS_TIME_CXX + +#if defined( OS2 ) +#define INCL_DOSMISC +#include <svpm.h> +#elif defined( WNT ) +#include <svwin.h> +#elif defined( WIN ) +#include <svwin.h> +#include <dos.h> +#elif defined( DOS ) +#include <dos.h> +#elif defined UNX +#include <limits.h> +#ifdef IRIX +#include <unistd.h> +#endif +#include <sys/times.h> +#elif defined( MAC ) +#include "mac_start.h" +#ifndef __OSUTILS__ +#include "OSUtils.h" +#include <MAC_Timer.h> +#include "mac_end.h" +#endif +#endif + +#include <time.h> +#include <time.hxx> + +#ifdef UNX +#include <math.h> +#endif + +#ifndef WNT +#ifndef localtime_r +extern "C" { +struct tm *localtime_r(const time_t *timep, struct tm *buffer); +} +#endif + +#ifndef gmtime_r +extern "C" { +struct tm *gmtime_r(const time_t *timep, struct tm *buffer); +} +#endif +#endif + +// ======================================================================= + +static long TimeToSec100( const Time& rTime ) +{ + short nSign = (rTime.GetTime() >= 0) ? +1 : -1; + long nHour = rTime.GetHour(); + long nMin = rTime.GetMin(); + long nSec = rTime.GetSec(); + long n100Sec = rTime.Get100Sec(); + +// Wegen Interal Compiler Error bei MSC, etwas komplizierter +// return (n100Sec + (nSec*100) + (nMin*60*100) + (nHour*60*60*100) * nSign); + + long nRet = n100Sec; + nRet += nSec*100; + nRet += nMin*60*100; + nRet += nHour*60*60*100; + + return (nRet * nSign); +} + +// ----------------------------------------------------------------------- + +static Time Sec100ToTime( long nSec100 ) +{ + short nSign; + if ( nSec100 < 0 ) + { + nSec100 *= -1; + nSign = -1; + } + else + nSign = 1; + + Time aTime( 0, 0, 0, nSec100 ); + aTime.SetTime( aTime.GetTime() * nSign ); + return aTime; +} + +// ======================================================================= + +Time::Time() +{ +#if defined( OS2 ) + DATETIME aDateTime; + DosGetDateTime( &aDateTime ); + + // Zeit zusammenbauen + nTime = (((long)aDateTime.hours)*1000000) + + (((long)aDateTime.minutes)*10000) + + (((long)aDateTime.seconds)*100) + + ((long)aDateTime.hundredths); +#elif defined( WNT ) + SYSTEMTIME aDateTime; + GetLocalTime( &aDateTime ); + + // Zeit zusammenbauen + nTime = (((long)aDateTime.wHour)*1000000) + + (((long)aDateTime.wMinute)*10000) + + (((long)aDateTime.wSecond)*100) + + ((long)aDateTime.wMilliseconds/10); +#elif ( defined( WIN ) || defined( DOS ) ) && !defined ( BLC ) + _dostime_t aTime; + _dos_gettime( &aTime ); + + // Zeit zusammenbauen + nTime = (((long)aTime.hour)*1000000) + + (((long)aTime.minute)*10000) + + (((long)aTime.second)*100) + + ((long)aTime.hsecond); +#elif ( defined( WIN ) || defined( DOS ) ) && defined ( BLC ) + dostime_t aTime; + _dos_gettime( &aTime ); + + // Zeit zusammenbauen + nTime = (((long)aTime.hour)*1000000) + + (((long)aTime.minute)*10000) + + (((long)aTime.second)*100) + + ((long)aTime.hsecond); +#elif defined( MAC ) + DateTimeRec dt; + ::GetTime(&dt); + nTime = (((long)dt.hour)*1000000) + + (((long)dt.minute)*10000) + + (((long)dt.second)*100); +#else + time_t nTmpTime; + struct tm aTime; + + // Zeit ermitteln + nTmpTime = time( 0 ); + + // Zeit zusammenbauen + if ( localtime_r( &nTmpTime, &aTime ) ) + { + nTime = (((long)aTime.tm_hour)*1000000) + + (((long)aTime.tm_min)*10000) + + (((long)aTime.tm_sec)*100); + } + else + nTime = 0; +#endif +} + +// ----------------------------------------------------------------------- + +Time::Time( ULONG nHour, ULONG nMin, ULONG nSec, ULONG n100Sec ) +{ + // Zeit normalisieren + nSec += n100Sec / 100; + n100Sec = n100Sec % 100; + nMin += nSec / 60; + nSec = nSec % 60; + nHour += nMin / 60; + nMin = nMin % 60; + + // Zeit zusammenbauen + nTime = (long)(n100Sec + (nSec*100) + (nMin*10000) + (nHour*1000000)); +} + +// ----------------------------------------------------------------------- + +void Time::SetHour( USHORT nNewHour ) +{ + short nSign = (nTime >= 0) ? +1 : -1; + long nMin = GetMin(); + long nSec = GetSec(); + long n100Sec = Get100Sec(); + + nTime = (n100Sec + (nSec*100) + (nMin*10000) + + (((long)nNewHour)*1000000)) * nSign; +} + +// ----------------------------------------------------------------------- + +void Time::SetMin( USHORT nNewMin ) +{ + short nSign = (nTime >= 0) ? +1 : -1; + long nHour = GetHour(); + long nSec = GetSec(); + long n100Sec = Get100Sec(); + + // kein Ueberlauf + nNewMin = nNewMin % 60; + + nTime = (n100Sec + (nSec*100) + (((long)nNewMin)*10000) + + (nHour*1000000)) * nSign; +} + +// ----------------------------------------------------------------------- + +void Time::SetSec( USHORT nNewSec ) +{ + short nSign = (nTime >= 0) ? +1 : -1; + long nHour = GetHour(); + long nMin = GetMin(); + long n100Sec = Get100Sec(); + + // kein Ueberlauf + nNewSec = nNewSec % 60; + + nTime = (n100Sec + (((long)nNewSec)*100) + (nMin*10000) + + (nHour*1000000)) * nSign; +} + +// ----------------------------------------------------------------------- + +void Time::Set100Sec( USHORT nNew100Sec ) +{ + short nSign = (nTime >= 0) ? +1 : -1; + long nHour = GetHour(); + long nMin = GetMin(); + long nSec = GetSec(); + + // kein Ueberlauf + nNew100Sec = nNew100Sec % 100; + + nTime = (((long)nNew100Sec) + (nSec*100) + (nMin*10000) + + (nHour*1000000)) * nSign; +} + +// ----------------------------------------------------------------------- + +long Time::GetMSFromTime() const +{ + short nSign = (nTime >= 0) ? +1 : -1; + long nHour = GetHour(); + long nMin = GetMin(); + long nSec = GetSec(); + long n100Sec = Get100Sec(); + + return (((nHour*3600000)+(nMin*60000)+(nSec*1000)+(n100Sec*10))*nSign); +} + +// ----------------------------------------------------------------------- + +void Time::MakeTimeFromMS( long nMS ) +{ + short nSign; + if ( nMS < 0 ) + { + nMS *= -1; + nSign = -1; + } + else + nSign = 1; + + Time aTime( 0, 0, 0, nMS/10 ); + SetTime( aTime.GetTime() * nSign ); +} + +// ----------------------------------------------------------------------- + +Time& Time::operator +=( const Time& rTime ) +{ + nTime = Sec100ToTime( TimeToSec100( *this ) + + TimeToSec100( rTime ) ).GetTime(); + return *this; +} + +// ----------------------------------------------------------------------- + +Time& Time::operator -=( const Time& rTime ) +{ + nTime = Sec100ToTime( TimeToSec100( *this ) - + TimeToSec100( rTime ) ).GetTime(); + return *this; +} + +// ----------------------------------------------------------------------- + +Time operator +( const Time& rTime1, const Time& rTime2 ) +{ + return Sec100ToTime( TimeToSec100( rTime1 ) + + TimeToSec100( rTime2 ) ); +} + +// ----------------------------------------------------------------------- + +Time operator -( const Time& rTime1, const Time& rTime2 ) +{ + return Sec100ToTime( TimeToSec100( rTime1 ) - + TimeToSec100( rTime2 ) ); +} + +// ----------------------------------------------------------------------- + +Time Time::GetUTCOffset() +{ +#if defined( OS2 ) +#undef timezone + DATETIME aDateTime; + DosGetDateTime( &aDateTime ); + + // Zeit zusammenbauen + if ( aDateTime.timezone != -1 ) + { + short nTempTime = (short)Abs( aDateTime.timezone ); + Time aTime( 0, (USHORT)nTempTime ); + if ( aDateTime.timezone > 0 ) + aTime = -aTime; + return aTime; + } + else + return Time( 0 ); +#elif defined( WNT ) + TIME_ZONE_INFORMATION aTimeZone; + aTimeZone.Bias = 0; + DWORD nTimeZoneRet = GetTimeZoneInformation( &aTimeZone ); + long nTempTime = aTimeZone.Bias; + if ( nTimeZoneRet == TIME_ZONE_ID_STANDARD ) + nTempTime += aTimeZone.StandardBias; + else if ( nTimeZoneRet == TIME_ZONE_ID_DAYLIGHT ) + nTempTime += aTimeZone.DaylightBias; + Time aTime( 0, (USHORT)Abs( nTempTime ) ); + if ( nTempTime > 0 ) + aTime = -aTime; + return aTime; +#elif ( defined( WIN ) || defined( DOS ) ) && defined ( BLC ) + static ULONG nCacheTicks = 0; + static long nCacheSecOffset = -1; + ULONG nTicks = Time::GetSystemTicks(); + time_t nTime; + tm aTM; + long nLocalTime; + long nUTC; + short nTempTime; + + // Evt. Wert neu ermitteln + if ( (nCacheSecOffset == -1) || ((nTicks - nCacheTicks) > 360000) ) + { + nTime = time( 0 ); + tm aTMTmp; + aTM = *localtime_r( &nTime, &aTMTmp); + nLocalTime = mktime( &aTM ); + aTM = *gmtime_r( &nTime, &aTMTmp); + nUTC = mktime( &aTM ); + nCacheTicks = nTicks; + nCacheSecOffset = (nLocalTime-nUTC) / 60; + } + + nTempTime = (short)Abs( nCacheSecOffset ); + Time aTime( 0, (USHORT)nTempTime ); + if ( nCacheSecOffset < 0 ) + aTime = -aTime; + return aTime; +#else + static ULONG nCacheTicks = 0; + static long nCacheSecOffset = -1; + ULONG nTicks = Time::GetSystemTicks(); + time_t nTime; + tm aTM; + long nLocalTime; + long nUTC; + short nTempTime; + + // Evt. Wert neu ermitteln + if ( (nCacheSecOffset == -1) || + ((nTicks - nCacheTicks) > 360000) || + ( nTicks < nCacheTicks ) // handle overflow + ) + { + nTime = time( 0 ); + localtime_r( &nTime, &aTM ); + nLocalTime = mktime( &aTM ); +#if defined( SOLARIS ) + // Solaris gmtime_r() seems not to handle daylight saving time + // flags correctly + nUTC = nLocalTime + ( aTM.tm_isdst == 0 ? timezone : altzone ); +#elif defined( LINUX ) + // Linux mktime() seems not to handle tm_isdst correctly + nUTC = nLocalTime - aTM.tm_gmtoff; +#else + gmtime_r( &nTime, &aTM ); + nUTC = mktime( &aTM ); +#endif + nCacheTicks = nTicks; + nCacheSecOffset = (nLocalTime-nUTC) / 60; + } + + nTempTime = (short)Abs( nCacheSecOffset ); + Time aTime( 0, (USHORT)nTempTime ); + if ( nCacheSecOffset < 0 ) + aTime = -aTime; + return aTime; +#endif +} + + +// ----------------------------------------------------------------------- + +ULONG Time::GetSystemTicks() +{ +#if defined( WIN ) || defined( WNT ) + return (ULONG)GetTickCount(); +#elif defined( OS2 ) + PM_ULONG nClock; + DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) ); + return (ULONG)nClock; +#elif defined( MAC ) + long long millisec; + Microseconds((UnsignedWide *)&millisec); + millisec = ( millisec + 500L ) / 1000L; + return (ULONG)millisec; +#else + static ULONG nImplTicksPerSecond = 0; + static double dImplTicksPerSecond; + static double dImplTicksULONGMAX; + struct tms aTms; + ULONG nTicks = (ULONG)times( &aTms ); + + if ( !nImplTicksPerSecond ) + { + nImplTicksPerSecond = CLK_TCK; + dImplTicksPerSecond = nImplTicksPerSecond; + dImplTicksULONGMAX = (double)(ULONG)ULONG_MAX; + } + + double fTicks = nTicks; + fTicks *= 1000; + fTicks /= dImplTicksPerSecond; + fTicks = fmod (fTicks, dImplTicksULONGMAX); + + return (ULONG)fTicks; +#endif +} + +// ----------------------------------------------------------------------- + +ULONG Time::GetProcessTicks() +{ +#if defined( WIN ) || defined( WNT ) + return (ULONG)GetTickCount(); +#elif defined( OS2 ) + PM_ULONG nClock; + DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) ); + return (ULONG)nClock; +#elif defined( MAC ) + long long millisec; + Microseconds((UnsignedWide *)&millisec); + millisec = ( millisec + 500L ) / 1000L; + return (ULONG)millisec; +#else + static ULONG nImplTicksPerSecond = 0; + static double dImplTicksPerSecond; + static double dImplTicksULONGMAX; + ULONG nTicks = (ULONG)clock(); + + if ( !nImplTicksPerSecond ) + { + nImplTicksPerSecond = CLOCKS_PER_SEC; + dImplTicksPerSecond = nImplTicksPerSecond; + dImplTicksULONGMAX = (double)(ULONG)ULONG_MAX; + } + + double fTicks = nTicks; + fTicks *= 1000; + fTicks /= dImplTicksPerSecond; + fTicks = fmod (fTicks, dImplTicksULONGMAX); + return (ULONG)fTicks; +#endif +} diff --git a/tools/source/debug/debug.cxx b/tools/source/debug/debug.cxx new file mode 100644 index 000000000000..cfa1ce5dfa1b --- /dev/null +++ b/tools/source/debug/debug.cxx @@ -0,0 +1,1581 @@ +/************************************************************************* + * + * $RCSfile: debug.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _TOOLS_DEBUG_CXX + +#ifndef MAC +#if defined (UNX) || defined (GCC) +#include <unistd.h> +#else +#include <direct.h> +#endif +#endif + +#include <time.h> +#include <stdarg.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> + +#ifdef OS2 +#define INCL_DOSSEMAPHORES +#define INCL_DOSMISC +#define INCL_WINDIALOGS +#include <svpm.h> +#endif + +#if defined ( WNT ) +#include <svwin.h> +#endif + +#include <debug.hxx> + +// ======================================================================= + +#ifdef DBG_UTIL + +// --- DbgErrors --- + +static sal_Char const DbgError_ProfEnd1[] = "DBG_PROF...() without DBG_PROFSTART(): "; +static sal_Char const DbgError_Xtor1[] = "DBG_DTOR() or DBG_CHKTHIS() without DBG_CTOR(): "; + +static sal_Char const DbgError_CtorDtor1[] = "this == NULL in class "; +static sal_Char const DbgError_CtorDtor2[] = "invalid this-Pointer %p in class "; +static sal_Char const DbgError_CtorDtor3[] = "Error-Msg from Object %p in class "; + +static sal_Char const DbgTrace_EnterCtor[] = "Enter Ctor from class "; +static sal_Char const DbgTrace_LeaveCtor[] = "Leave Ctor from class "; +static sal_Char const DbgTrace_EnterDtor[] = "Enter Dtor from class "; +static sal_Char const DbgTrace_LeaveDtor[] = "Leave Dtor from class "; +static sal_Char const DbgTrace_EnterMeth[] = "Enter method from class "; +static sal_Char const DbgTrace_LeaveMeth[] = "Leave method from class "; + +// --- PointerList --- + +#define PBLOCKCOUNT 1024 + +struct PBlock +{ + void* aData[PBLOCKCOUNT]; + USHORT nCount; + PBlock* pPrev; + PBlock* pNext; +}; + +class PointerList +{ +private: + PBlock* pFirst; + PBlock* pLast; + ULONG nCount; + +public: + PointerList() { pFirst = NULL; pLast = NULL; nCount = 0; } + ~PointerList(); + + void Add( const void* p ); + BOOL Remove( const void* p ); + + const void* Get( ULONG nPos ) const; + BOOL IsIn( const void* p ) const; + ULONG Count() const { return nCount; } +}; + +// --- Datentypen --- + +#define DBG_MAXNAME 28 + +struct ProfType +{ + ULONG nCount; + ULONG nTime; + ULONG nMinTime; + ULONG nMaxTime; + ULONG nStart; + ULONG nContinueTime; + ULONG nContinueStart; + sal_Char aName[DBG_MAXNAME+1]; +}; + +struct XtorType +{ + ULONG nCtorCalls; + ULONG nDtorCalls; + ULONG nMaxCount; + ULONG nStatics; + sal_Char aName[DBG_MAXNAME+1]; + BOOL bTest; + PointerList aThisList; +}; + +struct DebugData +{ + DbgData aDbgData; + USHORT bInit; + DbgPrintLine pDbgPrintMsgBox; + DbgPrintLine pDbgPrintWindow; + DbgPrintLine pDbgPrintShell; + DbgPrintLine pDbgPrintTestTool; + PointerList* pProfList; + PointerList* pXtorList; + DbgTestSolarMutexProc pDbgTestSolarMutex; +}; + +#define DBG_TEST_XTOR_EXTRA (DBG_TEST_XTOR_THIS | DBG_TEST_XTOR_FUNC | \ + DBG_TEST_XTOR_EXIT | DBG_TEST_XTOR_REPORT ) + +// ------------------------------ +// - statische Verwaltungsdaten - +// ------------------------------ + +static DebugData aDebugData = +{ + { + DBG_TEST_RESOURCE | DBG_TEST_MEM_INIT, + TRUE, + DBG_OUT_NULL, + DBG_OUT_NULL, + DBG_OUT_MSGBOX, + 0x77, + 0x55, + 0x33, + "", + "", + "", + "", + "", + "", + }, + FALSE, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL +}; + +#ifndef MAC +static sal_Char aCurPath[260]; +#endif + +static int bDbgImplInMain = FALSE; +static sal_Char aBuf[DBG_BUF_MAXLEN]; +static sal_Char aBufOut[DBG_BUF_MAXLEN]; + +// ======================================================================= + +#if defined( WNT ) +static CRITICAL_SECTION aImplCritDbgSection; +#elif defined( OS2 ) +static HMTX hImplCritDbgSection = 0; +#endif +static BOOL bImplCritDbgSectionInit = FALSE; + +// ----------------------------------------------------------------------- + +void ImplDbgInitLock() +{ +#if defined( WNT ) + InitializeCriticalSection( &aImplCritDbgSection ); +#elif defined( OS2 ) + DosCreateMutexSem( NULL, &hImplCritDbgSection, 0, FALSE ); +#endif + bImplCritDbgSectionInit = TRUE; +} + +// ----------------------------------------------------------------------- + +void ImplDbgDeInitLock() +{ +#if defined( WNT ) + DeleteCriticalSection( &aImplCritDbgSection ); +#elif defined( OS2 ) + DosCloseMutexSem( hImplCritDbgSection ); +#endif + bImplCritDbgSectionInit = FALSE; +} + +// ----------------------------------------------------------------------- + +void ImplDbgLock() +{ + if ( !bImplCritDbgSectionInit ) + return; + +#if defined( WNT ) + EnterCriticalSection( &aImplCritDbgSection ); +#elif defined( OS2 ) + DosRequestMutexSem( hImplCritDbgSection, SEM_INDEFINITE_WAIT ); +#endif +} + +// ----------------------------------------------------------------------- + +void ImplDbgUnlock() +{ + if ( !bImplCritDbgSectionInit ) + return; + +#if defined( WNT ) + LeaveCriticalSection( &aImplCritDbgSection ); +#elif defined( OS2 ) + DosReleaseMutexSem( hImplCritDbgSection ); +#endif +} + +// ======================================================================= + +// Aus DBMEM.CXX +#if (defined( WNT ) || defined( OS2 ) || defined( MAC )) && !defined ( SVX_LIGHT ) +#define SV_MEMMGR +#endif +#ifdef SV_MEMMGR +void DbgImpCheckMemory( void* p = NULL ); +void DbgImpCheckMemoryDeInit(); +void DbgImpMemoryInfo( sal_Char* pBuf ); +#endif + +#if defined( OS2 ) +#define FILE_LINEEND "\r\n" +#else +#define FILE_LINEEND "\n" +#endif + +// ======================================================================= + +static BOOL ImplActivateDebugger( const sal_Char* pMsg ) +{ +#if defined( WNT ) + static sal_Char aImplDbgOutBuf[DBG_BUF_MAXLEN]; + strcpy( aImplDbgOutBuf, pMsg ); + strcat( aImplDbgOutBuf, "\r\n" ); + OutputDebugString( aImplDbgOutBuf ); + DebugBreak(); + return TRUE; +#elif defined( MAC ) + debugstr( (sal_Char*)pLine ); + return TRUE; +#else + return FALSE; +#endif +} + +// ----------------------------------------------------------------------- + +static BOOL ImplCoreDump( const sal_Char* pMsg ) +{ +#if defined( WNT ) + DebugBreak(); +#else + long* pTemp = 0; + *pTemp = 0xCCCC; +#endif + return TRUE; +} + +// ======================================================================= + +static ULONG ImplGetPerfTime() +{ +#if defined( WNT ) + return (ULONG)GetTickCount(); +#elif defined( OS2 ) + PM_ULONG nClock; + DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, &nClock, sizeof( nClock ) ); + return (ULONG)nClock; +#elif defined( MAC ) + long long millisec; + Microseconds((UnsignedWide *)&millisec); + millisec = ( millisec + 500L ) / 1000L; + return (ULONG)millisec; +#else + static ULONG nImplTicksPerSecond = 0; + static double dImplTicksPerSecond; + ULONG nTicks = (ULONG)clock(); + + if ( !nImplTicksPerSecond ) + { + nImplTicksPerSecond = CLOCKS_PER_SEC; + dImplTicksPerSecond = nImplTicksPerSecond; + } + + double fTicks = nTicks; + fTicks *= 1000; + fTicks /= dImplTicksPerSecond; + return (ULONG)fTicks; +#endif +} + +// ----------------------------------------------------------------------- + +#if defined( OS2 ) + +typedef HFILE FILETYPE; + +static FILETYPE FileOpen( const sal_Char* pFileName, const sal_Char* pOpenMode ) +{ + HFILE hFile = 0; + ULONG lAction = 0; + ULONG nOpen1 = FILE_OPEN; + ULONG nOpen2 = OPEN_SHARE_DENYWRITE | OPEN_ACCESS_READONLY; + + if ( *pOpenMode == 'w' ) + { + nOpen1 = OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW; + nOpen2 = OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYREADWRITE; + } + else if ( *pOpenMode == 'a' ) + { + nOpen1 = OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS; + nOpen2 = OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYREADWRITE; + } + + APIRET nRet = DosOpen( pFileName, &hFile, &lAction, 0, + FILE_NORMAL, nOpen1, nOpen2, 0L ); + + if ( nRet ) + return NULL; + else + { + if ( *pOpenMode == 'a' ) + { + ULONG nTemp; + DosSetFilePtr( hFile, 0, FILE_END, &nTemp ); + } + + return hFile; + } +} + +static ULONG FileRead( void* pData, int n1, int n2, FILETYPE pFile ) +{ + ULONG nRead; + DosRead( pFile, pData, n1*n2, &nRead ); + return nRead; +} + +static ULONG FileWrite( void* pData, int n1, int n2, FILETYPE pFile ) +{ + ULONG nWritten; + DosWrite( pFile, pData, n1*n2, &nWritten ); + return nWritten; +} + +static void FilePrintF( FILETYPE pFile, const sal_Char* pFStr, ... ) +{ + static sal_Char aTempBuf[DBG_BUF_MAXLEN]; + + va_list pList; + + va_start( pList, pFStr ); + vsprintf( aTempBuf, pFStr, pList ); + va_end( pList ); + + FileWrite( aTempBuf, strlen( aTempBuf ), 1, pFile ); +} + +static void FileClose( FILETYPE pFile ) +{ + DosClose( pFile ); +} + +#else + +typedef FILE* FILETYPE; +#define FileOpen fopen +#define FileRead fread +#define FileWrite fwrite +#define FilePrintF fprintf +#define FileClose fclose + +#endif + +// ======================================================================= + +PointerList::~PointerList() +{ + PBlock* pBlock = pFirst; + while ( pBlock ) + { + PBlock* pNextBlock = pBlock->pNext; + delete pBlock; + pBlock = pNextBlock; + } +} + +// ----------------------------------------------------------------------- + +void PointerList::Add( const void* p ) +{ + if ( !pFirst ) + { + pFirst = new PBlock; + memset( pFirst->aData, 0, PBLOCKCOUNT * sizeof( void* ) ); + pFirst->nCount = 0; + pFirst->pPrev = NULL; + pFirst->pNext = NULL; + pLast = pFirst; + } + + PBlock* pBlock = pFirst; + while ( pBlock && (pBlock->nCount == PBLOCKCOUNT) ) + pBlock = pBlock->pNext; + + if ( !pBlock ) + { + pBlock = new PBlock; + memset( pBlock->aData, 0, PBLOCKCOUNT * sizeof( void* ) ); + pBlock->nCount = 0; + pBlock->pPrev = pLast; + pBlock->pNext = NULL; + pLast->pNext = pBlock; + pLast = pBlock; + } + + USHORT i = 0; + while ( pBlock->aData[i] ) + i++; + + pBlock->aData[i] = (void*)p; + pBlock->nCount++; + nCount++; +} + +// ----------------------------------------------------------------------- + +BOOL PointerList::Remove( const void* p ) +{ + if ( !p ) + return FALSE; + + PBlock* pBlock = pFirst; + while ( pBlock ) + { + USHORT i = 0; + while ( i < PBLOCKCOUNT ) + { + if ( ((ULONG)p) == ((ULONG)pBlock->aData[i]) ) + { + pBlock->aData[i] = NULL; + pBlock->nCount--; + nCount--; + + if ( !pBlock->nCount ) + { + if ( pBlock->pPrev ) + pBlock->pPrev->pNext = pBlock->pNext; + if ( pBlock->pNext ) + pBlock->pNext->pPrev = pBlock->pPrev; + if ( pBlock == pFirst ) + pFirst = pBlock->pNext; + if ( pBlock == pLast ) + pLast = pBlock->pPrev; + delete pBlock; + } + + return TRUE; + } + i++; + } + + pBlock = pBlock->pNext; + } + + return FALSE; +} + +// ----------------------------------------------------------------------- + +const void* PointerList::Get( ULONG nPos ) const +{ + if ( nCount <= nPos ) + return NULL; + + PBlock* pBlock = pFirst; + ULONG nStart = 0; + while ( pBlock ) + { + USHORT i = 0; + while ( i < PBLOCKCOUNT ) + { + if ( pBlock->aData[i] ) + { + nStart++; + if ( (nStart-1) == nPos ) + return pBlock->aData[i]; + } + + i++; + } + + pBlock = pBlock->pNext; + } + + return NULL; +} + +// ----------------------------------------------------------------------- + +BOOL PointerList::IsIn( const void* p ) const +{ + if ( !p ) + return FALSE; + + PBlock* pBlock = pFirst; + while ( pBlock ) + { + USHORT i = 0; + while ( i < PBLOCKCOUNT ) + { + if ( ((ULONG)p) == ((ULONG)pBlock->aData[i]) ) + return TRUE; + i++; + } + + pBlock = pBlock->pNext; + } + + return FALSE; +} + + +// ======================================================================= + +static void DbgGetDbgFileName( sal_Char* pStr ) +{ +#if defined( UNX ) + const sal_Char* pName = getenv("DBGSV_INIT"); + if ( !pName ) + pName = ".dbgsv.init"; + strcpy( pStr, pName ); +#elif defined( WNT ) + const sal_Char* pName = getenv("DBGSV_INIT"); + if ( pName ) + strcpy( pStr, pName ); + else + GetProfileStringA( "sv", "dbgsv", "dbgsv.ini", pStr, 200 ); +#elif defined( OS2 ) + PrfQueryProfileString( HINI_PROFILE, (PSZ)"SV", (PSZ)"DBGSV", + "dbgsv.ini", (PSZ)pStr, 200 ); +#else + strcpy( pStr, "dbgsv.ini" ); +#endif +} + +// ----------------------------------------------------------------------- + +static void DbgGetLogFileName( sal_Char* pStr ) +{ +#if defined( UNX ) + const sal_Char* pName = getenv("DBGSV_LOG"); + if ( !pName ) + pName = "dbgsv.log"; + strcpy( pStr, pName ); +#elif defined( WNT ) + const sal_Char* pName = getenv("DBGSV_LOG"); + if ( pName ) + strcpy( pStr, pName ); + else + GetProfileStringA( "sv", "dbgsvlog", "dbgsv.log", pStr, 200 ); +#elif defined( OS2 ) + PrfQueryProfileString( HINI_PROFILE, (PSZ)"SV", (PSZ)"DBGSVLOG", + "dbgsv.log", (PSZ)pStr, 200 ); +#else + strcpy( pStr, "dbgsv.log" ); +#endif +} + +// ----------------------------------------------------------------------- + +static int DbgImplIsAllErrorOut() +{ +#if defined( WNT ) + const sal_Char* pName = getenv("UPDATER"); + if ( pName && (strcmp( pName, "YES" ) == 0) ) + return TRUE; + if ( GetProfileInt( "sv", "dbgallerrorout", 0 ) ) + return TRUE; + else + return FALSE; +#elif defined( OS2 ) + const sal_Char* pName = getenv("UPDATER"); + if ( pName && (strcmp( pName, "YES" ) == 0) ) + return TRUE; + if ( PrfQueryProfileInt( HINI_PROFILE, (PSZ)"SV", (PSZ)"DBGALLERROROUT", 0 ) ) + return TRUE; + else + return FALSE; +#else + return TRUE; +#endif +} + +// ----------------------------------------------------------------------- + +static void DbgDebugBeep() +{ +#if defined( WNT ) + MessageBeep( MB_ICONHAND ); +#elif defined( OS2 ) + WinAlarm( HWND_DESKTOP, WA_ERROR ); +#endif +} + +// ----------------------------------------------------------------------- + +static DebugData* GetDebugData() +{ + if ( !aDebugData.bInit ) + { + aDebugData.bInit = TRUE; + + // Default Debug-Namen setzen + DbgGetLogFileName( aDebugData.aDbgData.aDebugName ); + + // DEBUG.INI-File + FILETYPE pDbgFile; + DbgGetDbgFileName( aBuf ); + if ( (pDbgFile = FileOpen( aBuf, "r" )) != NULL ) + { + FileRead( &(aDebugData.aDbgData), sizeof( DbgData ), 1, pDbgFile ); + FileClose( pDbgFile ); + } + +#ifndef MAC + getcwd( aCurPath, sizeof( aCurPath ) ); +#endif + + // Daten initialisieren + if ( aDebugData.aDbgData.nTestFlags & DBG_TEST_XTOR ) + aDebugData.pXtorList = new PointerList; + if ( aDebugData.aDbgData.nTestFlags & DBG_TEST_PROFILING ) + aDebugData.pProfList = new PointerList; + if ( aDebugData.aDbgData.nErrorOut < DBG_OUT_MSGBOX ) + { + if ( !DbgImplIsAllErrorOut() ) + aDebugData.aDbgData.nErrorOut = DBG_OUT_MSGBOX; + } + } + + return &aDebugData; +} + +// ----------------------------------------------------------------------- + +inline DebugData* ImplGetDebugData() +{ + if ( !aDebugData.bInit ) + return GetDebugData(); + else + return &aDebugData; +} + +// ----------------------------------------------------------------------- + +static FILETYPE ImplDbgInitFile() +{ + static BOOL bFileInit = FALSE; + +#ifndef MAC + getcwd( aBuf, sizeof( aBuf ) ); + chdir( aCurPath ); +#endif + + DebugData* pData = GetDebugData(); + FILETYPE pDebugFile; + + if ( !bFileInit ) + { + bFileInit = TRUE; + + if ( pData->aDbgData.bOverwrite ) + pDebugFile = FileOpen( pData->aDbgData.aDebugName, "w" ); + else + pDebugFile = FileOpen( pData->aDbgData.aDebugName, "a" ); + + if ( pDebugFile ) + { + time_t nTime = time( 0 ); + tm* pTime; +#ifdef UNX + tm aTime; + pTime = localtime_r( &nTime, &aTime ); +#else + pTime = localtime( &nTime ); +#endif + + // Header ausgeben + FilePrintF( pDebugFile, "******************************************************************************%s", FILE_LINEEND ); + FilePrintF( pDebugFile, "%s%s", pData->aDbgData.aDebugName, FILE_LINEEND ); + if ( pTime ) + FilePrintF( pDebugFile, "%s%s", asctime( pTime ), FILE_LINEEND ); + } + } + else + pDebugFile = FileOpen( pData->aDbgData.aDebugName, "a" ); + +#ifndef MAC + chdir( aBuf ); +#endif + + return pDebugFile; +} + +// ----------------------------------------------------------------------- + +static void ImplDbgPrintFile( const sal_Char* pLine ) +{ + FILETYPE pDebugFile = ImplDbgInitFile(); + + if ( pDebugFile ) + { + FilePrintF( pDebugFile, "%s%s", pLine, FILE_LINEEND ); + FileClose( pDebugFile ); + } +} + +// ----------------------------------------------------------------------- + +static int ImplStrSearch( const sal_Char* pSearchStr, int nSearchLen, + const sal_Char* pStr, int nLen ) +{ + int nPos = 0; + while ( nPos+nSearchLen <= nLen ) + { + if ( strncmp( pStr+nPos, pSearchStr, nSearchLen ) == 0 ) + return 1; + nPos++; + } + + return 0; +} + +// ----------------------------------------------------------------------- + +static int ImplDbgFilter( const sal_Char* pFilter, const sal_Char* pMsg, + int bEmpty ) +{ + int nStrLen = strlen( pFilter ); + if ( !nStrLen ) + return bEmpty; + + int nMsgLen = strlen( pMsg ); + const sal_Char* pTok = pFilter; + int nTok = 0; + while ( pTok[nTok] ) + { + if ( pTok[nTok] == ';' ) + { + if ( nTok && ImplStrSearch( pTok, nTok, pMsg, nMsgLen ) ) + return TRUE; + + pTok += nTok+1; + nTok = 0; + } + + nTok++; + } + + if ( nTok && ImplStrSearch( pTok, nTok, pMsg, nMsgLen ) ) + return TRUE; + else + return FALSE; +} + +// ----------------------------------------------------------------------- + +static void DebugInit() +{ + bDbgImplInMain = TRUE; + ImplDbgInitLock(); +} + +// ----------------------------------------------------------------------- + +static void DebugDeInit() +{ + DebugData* pData = GetDebugData(); + ULONG i; + ULONG nCount; + ULONG nOldOut; + + // Statistik-Ausgaben immer in File + nOldOut = pData->aDbgData.nTraceOut; + pData->aDbgData.nTraceOut = DBG_OUT_FILE; + + // Xtor-Liste ausgeben + if ( pData->pXtorList && pData->pXtorList->Count() && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_REPORT) ) + { + DbgOutf( "------------------------------------------------------------------------------" ); + DbgOutf( "Object Report" ); + DbgOutf( "------------------------------------------------------------------------------" ); + DbgOutf( "%-27s : %-9s : %-9s : %-7s : %-3s : %-6s :", + "XTor-List", "Ctor", "Dtor", "MaxInst", "St.", "Diff." ); + DbgOutf( "----------------------------:-----------:-----------:---------:----:---------:" ); + for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) + { + XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); + if ( pXtorData->bTest ) + { + // Static-Objekte dazurechnen + pXtorData->nDtorCalls += pXtorData->nStatics; + if ( pXtorData->nStatics && (pXtorData->nDtorCalls > pXtorData->nCtorCalls) ) + pXtorData->nDtorCalls = pXtorData->nCtorCalls; + DbgOutf( "%-27s : %9lu : %9lu : %7lu : %3lu : %4lu %-1s :", + pXtorData->aName, pXtorData->nCtorCalls, pXtorData->nDtorCalls, + pXtorData->nMaxCount, pXtorData->nStatics, + pXtorData->nCtorCalls - pXtorData->nDtorCalls, + (pXtorData->nCtorCalls - pXtorData->nDtorCalls) ? "!" : " " ); + } + } + DbgOutf( "==============================================================================" ); + } + + // Aufraeumen + if ( pData->pXtorList ) + { + for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) + { + XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); + delete pXtorData; + } + delete pData->pXtorList; + pData->pXtorList = NULL; + } + + // Alles auf FALSE setzen, damit globale Variablen nicht das + // System zum Abstuerzen bringt. Dabei muessen aber die + // Memory-Flags erhalten bleiben, da sonst new/delete in globalen + // Variablen abstuerzen, da die Pointeranpassung dann nicht mehr richtig + // funktioniert + pData->aDbgData.nTraceOut = nOldOut; + pData->aDbgData.nTestFlags &= (DBG_TEST_MEM | DBG_TEST_PROFILING); + pData->pDbgPrintTestTool = NULL; + pData->pDbgPrintShell = NULL; + pData->pDbgPrintWindow = NULL; + pData->pDbgPrintShell = NULL; + ImplDbgDeInitLock(); +} + +// ----------------------------------------------------------------------- + +static void DebugGlobalDeInit() +{ + DebugData* pData = GetDebugData(); + ULONG i; + ULONG nCount; + ULONG nOldOut; + + // Statistik-Ausgaben immer in File + nOldOut = pData->aDbgData.nTraceOut; + pData->aDbgData.nTraceOut = DBG_OUT_FILE; + + // Profileliste ausgeben + if ( pData->pProfList && pData->pProfList->Count() ) + { + DbgOutf( "------------------------------------------------------------------------------" ); + DbgOutf( "Profiling Report" ); + DbgOutf( "------------------------------------------------------------------------------" ); + DbgOutf( "%-25s : %-9s : %-6s : %-6s : %-6s : %-9s :", + "Prof-List (ms)", "Time", "Min", "Max", "Ave", "Count" ); + DbgOutf( "--------------------------:-----------:--------:--------:--------:-----------:" ); + for( i = 0, nCount = pData->pProfList->Count(); i < nCount; i++ ) + { + ProfType* pProfData = (ProfType*)pData->pProfList->Get( i ); + ULONG nAve = pProfData->nTime / pProfData->nCount; + DbgOutf( "%-25s : %9lu : %6lu : %6lu : %6lu : %9lu :", + pProfData->aName, pProfData->nTime, + pProfData->nMinTime, pProfData->nMaxTime, nAve, + pProfData->nCount ); + } + DbgOutf( "==============================================================================" ); + } + + // Aufraeumen + if ( pData->pProfList ) + { + for( i = 0, nCount = pData->pProfList->Count(); i < nCount; i++ ) + { + ProfType* pProfData = (ProfType*)pData->pProfList->Get( i ); + delete pProfData; + } + delete pData->pProfList; + pData->pProfList = NULL; + } + +#ifdef SV_MEMMGR + DbgImpCheckMemoryDeInit(); +#endif + + // Profiling-Flags ausschalten + pData->aDbgData.nTraceOut = nOldOut; + pData->aDbgData.nTestFlags &= ~DBG_TEST_PROFILING; +} + +// ----------------------------------------------------------------------- + +void ImpDbgOutfBuf( sal_Char* pBuf, const sal_Char* pFStr, ... ) +{ + va_list pList; + + va_start( pList, pFStr ); + vsprintf( aBuf, pFStr, pList ); + va_end( pList ); + + strcat( pBuf, aBuf ); + strcat( pBuf, "\n" ); +} + +// ----------------------------------------------------------------------- + +static void DebugXTorInfo( sal_Char* pBuf ) +{ + DebugData* pData = GetDebugData(); + ULONG i; + ULONG nCount; + + // Xtor-Liste ausgeben + if ( pData->pXtorList && pData->pXtorList->Count() && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_REPORT) ) + { + ImpDbgOutfBuf( pBuf, "------------------------------------------------------------------------------" ); + ImpDbgOutfBuf( pBuf, "Object Report" ); + ImpDbgOutfBuf( pBuf, "------------------------------------------------------------------------------" ); + ImpDbgOutfBuf( pBuf, "%-27s : %-9s : %-9s : %-7s : %-3s : %-6s :", + "XTor-List", "Ctor", "Dtor", "MaxInst", "St.", "Diff." ); + ImpDbgOutfBuf( pBuf, "----------------------------:-----------:-----------:---------:----:---------:" ); + for( i = 0, nCount = pData->pXtorList->Count(); i < nCount; i++ ) + { + XtorType* pXtorData = (XtorType*)pData->pXtorList->Get( i ); + if ( pXtorData->bTest ) + { + ImpDbgOutfBuf( pBuf, "%-27s : %9lu : %9lu : %7lu : %3lu : %6lu :", + pXtorData->aName, pXtorData->nCtorCalls, pXtorData->nDtorCalls, + pXtorData->nMaxCount, pXtorData->nStatics, + pXtorData->nCtorCalls - pXtorData->nDtorCalls ); + } + } + ImpDbgOutfBuf( pBuf, "==============================================================================" ); + ImpDbgOutfBuf( pBuf, "" ); + } +} + +// ----------------------------------------------------------------------- + +void* DbgFunc( USHORT nAction, void* pParam ) +{ + DebugData* pData = ImplGetDebugData(); + + if ( nAction == DBG_FUNC_GETDATA ) + return (void*)&(pData->aDbgData); + else + { + switch ( nAction ) + { + case DBG_FUNC_DEBUGSTART: + DebugInit(); + break; + + case DBG_FUNC_DEBUGEND: + DebugDeInit(); + break; + + case DBG_FUNC_GLOBALDEBUGEND: + DebugGlobalDeInit(); + break; + + case DBG_FUNC_SETPRINTMSGBOX: + pData->pDbgPrintMsgBox = (DbgPrintLine)pParam; + break; + + case DBG_FUNC_SETPRINTWINDOW: + pData->pDbgPrintWindow = (DbgPrintLine)pParam; + break; + + case DBG_FUNC_SETPRINTSHELL: + pData->pDbgPrintShell = (DbgPrintLine)pParam; + break; + + case DBG_FUNC_SETPRINTTESTTOOL: + pData->pDbgPrintTestTool = (DbgPrintLine)pParam; + break; + + case DBG_FUNC_SAVEDATA: + { + FILETYPE pDbgFile; + DbgGetDbgFileName( aBuf ); + if ( (pDbgFile = FileOpen( aBuf, "w" )) != NULL ) + { + FileWrite( pParam, sizeof( DbgData ), 1, pDbgFile ); + FileClose( pDbgFile ); + } + } + break; + + case DBG_FUNC_MEMTEST: +#ifdef SV_MEMMGR + DbgImpCheckMemory( pParam ); +#endif + break; + + case DBG_FUNC_XTORINFO: + DebugXTorInfo( (sal_Char*)pParam ); + break; + + case DBG_FUNC_MEMINFO: +#ifdef SV_MEMMGR + DbgImpMemoryInfo( (sal_Char*)pParam ); +#endif + break; + + case DBG_FUNC_COREDUMP: + ImplCoreDump( NULL ); + break; + + case DBG_FUNC_ALLERROROUT: + return (void*)(ULONG)DbgImplIsAllErrorOut(); + + case DBG_FUNC_SETTESTSOLARMUTEX: + pData->pDbgTestSolarMutex = (DbgTestSolarMutexProc)pParam; + break; + + case DBG_FUNC_TESTSOLARMUTEX: + if ( pData->pDbgTestSolarMutex ) + pData->pDbgTestSolarMutex(); + break; + + case DBG_FUNC_PRINTFILE: + ImplDbgPrintFile( (const sal_Char*)pParam ); + break; + } + + return NULL; + } +} + +// ----------------------------------------------------------------------- + +void DbgProf( USHORT nAction, DbgDataType* pDbgData ) +{ + // Ueberhaupt Profiling-Test an + DebugData* pData = ImplGetDebugData(); + ProfType* pProfData = (ProfType*)pDbgData->pData; + ULONG nTime; + + if ( !(pData->aDbgData.nTestFlags & DBG_TEST_PROFILING) ) + return; + + if ( (nAction != DBG_PROF_START) && !pProfData ) + { + strcpy( aBuf, DbgError_ProfEnd1 ); + strcat( aBuf, pDbgData->pName ); + DbgError( aBuf ); + return; + } + + switch ( nAction ) + { + case DBG_PROF_START: + if ( !pDbgData->pData ) + { + pDbgData->pData = (void*)new ProfType; + pProfData = (ProfType*)pDbgData->pData; + strncpy( pProfData->aName, pDbgData->pName, DBG_MAXNAME ); + pProfData->aName[DBG_MAXNAME] = '\0'; + pProfData->nCount = 0; + pProfData->nTime = 0; + pProfData->nMinTime = 0xFFFFFFFF; + pProfData->nMaxTime = 0; + pProfData->nStart = 0xFFFFFFFF; + pProfData->nContinueTime = 0; + pProfData->nContinueStart = 0xFFFFFFFF; + pData->pProfList->Add( (void*)pProfData ); + } + + if ( pProfData->nStart == 0xFFFFFFFF ) + { + pProfData->nStart = ImplGetPerfTime(); + pProfData->nCount++; + } + break; + + case DBG_PROF_STOP: + nTime = ImplGetPerfTime(); + + if ( pProfData->nStart == 0xFFFFFFFF ) + { + DbgError( DbgError_ProfEnd1 ); + return; + } + + if ( pProfData->nContinueStart != 0xFFFFFFFF ) + { + pProfData->nContinueTime += ImplGetPerfTime() - pProfData->nContinueStart; + pProfData->nContinueStart = 0xFFFFFFFF; + } + + nTime -= pProfData->nStart; + nTime -= pProfData->nContinueTime; + + if ( nTime < pProfData->nMinTime ) + pProfData->nMinTime = nTime; + + if ( nTime > pProfData->nMaxTime ) + pProfData->nMaxTime = nTime; + + pProfData->nTime += nTime; + + pProfData->nStart = 0xFFFFFFFF; + pProfData->nContinueTime = 0; + pProfData->nContinueStart = 0xFFFFFFFF; + break; + + case DBG_PROF_CONTINUE: + if ( pProfData->nContinueStart != 0xFFFFFFFF ) + { + pProfData->nContinueTime += ImplGetPerfTime() - pProfData->nContinueStart; + pProfData->nContinueStart = 0xFFFFFFFF; + } + break; + + case DBG_PROF_PAUSE: + if ( pProfData->nContinueStart == 0xFFFFFFFF ) + pProfData->nContinueStart = ImplGetPerfTime(); + break; + } +} + +// ----------------------------------------------------------------------- + +void DbgXtor( DbgDataType* pDbgData, USHORT nAction, const void* pThis, + DbgUsr fDbgUsr ) +{ + DebugData* pData = ImplGetDebugData(); + + // Verbindung zu Debug-Memory-Manager testen +#ifdef SV_MEMMGR + if ( pData->aDbgData.nTestFlags & DBG_TEST_MEM_XTOR ) + DbgImpCheckMemory(); +#endif + + // Schnell-Test + if ( !(pData->aDbgData.nTestFlags & DBG_TEST_XTOR) ) + return; + + XtorType* pXtorData = (XtorType*)pDbgData->pData; + if ( !pXtorData ) + { + pDbgData->pData = (void*)new XtorType; + pXtorData = (XtorType*)pDbgData->pData; + strncpy( pXtorData->aName, pDbgData->pName, DBG_MAXNAME ); + pXtorData->aName[DBG_MAXNAME] = '\0'; + pXtorData->nCtorCalls = 0; + pXtorData->nDtorCalls = 0; + pXtorData->nMaxCount = 0; + pXtorData->nStatics = 0; + pXtorData->bTest = TRUE; + pData->pXtorList->Add( (void*)pXtorData ); + + if ( !ImplDbgFilter( pData->aDbgData.aInclClassFilter, pXtorData->aName, TRUE ) ) + pXtorData->bTest = FALSE; + if ( ImplDbgFilter( pData->aDbgData.aExclClassFilter, pXtorData->aName, FALSE ) ) + pXtorData->bTest = FALSE; + } + if ( !pXtorData->bTest ) + return; + + USHORT nAct = nAction & ~DBG_XTOR_DTOROBJ; + + // Trace (Enter) + if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_TRACE) && + !(nAction & DBG_XTOR_DTOROBJ) ) + { + if ( nAct != DBG_XTOR_CHKOBJ ) + { + if ( nAct == DBG_XTOR_CTOR ) + strcpy( aBuf, DbgTrace_EnterCtor ); + else if ( nAct == DBG_XTOR_DTOR ) + strcpy( aBuf, DbgTrace_EnterDtor ); + else + strcpy( aBuf, DbgTrace_EnterMeth ); + strcat( aBuf, pDbgData->pName ); + DbgTrace( aBuf ); + } + } + + // Sind noch Xtor-Tests als Trace an + if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXTRA ) + { + // DBG_CTOR-Aufruf vor allen anderen DBG_XTOR-Aufrufen + if ( ((nAction & ~DBG_XTOR_DTOROBJ) != DBG_XTOR_CTOR) && !pDbgData->pData ) + { + strcpy( aBuf, DbgError_Xtor1 ); + strcat( aBuf, pDbgData->pName ); + DbgError( aBuf ); + return; + } + + // Testen, ob This-Pointer gueltig + if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) + { + if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) || + !(nAction & DBG_XTOR_DTOROBJ) ) + { + // This-Pointer == NULL + if ( !pThis ) + { + strcpy( aBuf, DbgError_CtorDtor1 ); + strcat( aBuf, pDbgData->pName ); + DbgError( aBuf ); + return; + } + + if ( (nAction & ~DBG_XTOR_DTOROBJ) != DBG_XTOR_CTOR ) + { + if ( !pXtorData->aThisList.IsIn( pThis ) ) + { + sprintf( aBuf, DbgError_CtorDtor2, pThis ); + strcat( aBuf, pDbgData->pName ); + DbgError( aBuf ); + } + } + } + } + + // Function-Test durchfuehren und Verwaltungsdaten updaten + const sal_Char* pMsg = NULL; + switch ( nAction & ~DBG_XTOR_DTOROBJ ) + { + case DBG_XTOR_CTOR: + if ( nAction & DBG_XTOR_DTOROBJ ) + { + if ( fDbgUsr && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) + pMsg = fDbgUsr( pThis ); + } + else + { + pXtorData->nCtorCalls++; + if ( !bDbgImplInMain ) + pXtorData->nStatics++; + if ( (pXtorData->nCtorCalls-pXtorData->nDtorCalls) > pXtorData->nMaxCount ) + pXtorData->nMaxCount = pXtorData->nCtorCalls - pXtorData->nDtorCalls; + + if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) + pXtorData->aThisList.Add( pThis ); + } + break; + + case DBG_XTOR_DTOR: + if ( nAction & DBG_XTOR_DTOROBJ ) + { + pXtorData->nDtorCalls++; + if ( pData->aDbgData.nTestFlags & DBG_TEST_XTOR_THIS ) + pXtorData->aThisList.Remove( pThis ); + } + else + { + if ( fDbgUsr && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) + pMsg = fDbgUsr( pThis ); + } + break; + + case DBG_XTOR_CHKTHIS: + case DBG_XTOR_CHKOBJ: + if ( nAction & DBG_XTOR_DTOROBJ ) + { + if ( fDbgUsr && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_EXIT) && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) + pMsg = fDbgUsr( pThis ); + } + else + { + if ( fDbgUsr && + (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_FUNC) ) + pMsg = fDbgUsr( pThis ); + } + break; + } + + // Gegebenenfalls Fehlermeldung ausgeben + if ( pMsg ) + { + sprintf( aBuf, DbgError_CtorDtor3, pThis ); + strcat( aBuf, pDbgData->pName ); + strcat( aBuf, ": \n" ); + strcat( aBuf, pMsg ); + DbgError( aBuf ); + } + } + + // Trace (Leave) + if ( (pData->aDbgData.nTestFlags & DBG_TEST_XTOR_TRACE) && + (nAction & DBG_XTOR_DTOROBJ) ) + { + if ( nAct != DBG_XTOR_CHKOBJ ) + { + if ( nAct == DBG_XTOR_CTOR ) + strcpy( aBuf, DbgTrace_LeaveCtor ); + else if ( nAct == DBG_XTOR_DTOR ) + strcpy( aBuf, DbgTrace_LeaveDtor ); + else + strcpy( aBuf, DbgTrace_LeaveMeth ); + strcat( aBuf, pDbgData->pName ); + DbgTrace( aBuf ); + } + } +} + +// ----------------------------------------------------------------------- + +void DbgOut( const sal_Char* pMsg, USHORT nDbgOut, const sal_Char* pFile, USHORT nLine ) +{ + static BOOL bIn = FALSE; + DebugData* pData = GetDebugData(); + sal_Char* pStr; + ULONG nOut; + int nBufLen = 0; + + if ( bIn ) + return; + bIn = TRUE; + + if ( nDbgOut == DBG_OUT_ERROR ) + { + nOut = pData->aDbgData.nErrorOut; + pStr = "Error: "; + if ( pData->aDbgData.nErrorOut == DBG_OUT_FILE ) + DbgDebugBeep(); + } + else if ( nDbgOut == DBG_OUT_WARNING ) + { + nOut = pData->aDbgData.nWarningOut; + pStr = "Warning: "; + } + else + { + nOut = pData->aDbgData.nTraceOut; + pStr = NULL; + } + + if ( nOut == DBG_OUT_NULL ) + { + bIn = FALSE; + return; + } + + if ( (nDbgOut != DBG_OUT_ERROR) || DbgImplIsAllErrorOut() ) + { + if ( !ImplDbgFilter( pData->aDbgData.aInclFilter, pMsg, TRUE ) ) + { + bIn = FALSE; + return; + } + if ( ImplDbgFilter( pData->aDbgData.aExclFilter, pMsg, FALSE ) ) + { + bIn = FALSE; + return; + } + } + + ImplDbgLock(); + + if ( pStr ) + { + strcpy( aBufOut, pStr ); + nBufLen = strlen( pStr ); + } + else + aBufOut[0] = '\0'; + + int nMsgLen = strlen( pMsg ); + if ( nBufLen+nMsgLen > DBG_BUF_MAXLEN ) + { + int nCopyLen = DBG_BUF_MAXLEN-nBufLen-3; + strncpy( &(aBufOut[nBufLen]), pMsg, nCopyLen ); + strcpy( &(aBufOut[nBufLen+nCopyLen]), "..." ); + } + else + strcpy( &(aBufOut[nBufLen]), pMsg ); + + if ( pFile && nLine && (nBufLen+nMsgLen < DBG_BUF_MAXLEN) ) + { + if ( nOut == DBG_OUT_MSGBOX ) + strcat( aBufOut, "\n" ); + else + strcat( aBufOut, " " ); + strcat( aBufOut, "From File " ); + strcat( aBufOut, pFile ); + strcat( aBufOut, " at Line " ); + + // Line in String umwandeln und dranhaengen + sal_Char aLine[9]; + sal_Char* pLine = &aLine[7]; + USHORT i; + memset( aLine, 0, sizeof( aLine ) ); + do + { + i = nLine % 10; + pLine--; + *(pLine) = (sal_Char)i + 48; + nLine /= 10; + } + while ( nLine ); + strcat( aBufOut, pLine ); + } + + if ( nOut == DBG_OUT_COREDUMP ) + { + if ( !ImplCoreDump( aBufOut ) ) + nOut = DBG_OUT_DEBUGGER; + } + + if ( nOut == DBG_OUT_DEBUGGER ) + { + if ( !ImplActivateDebugger( aBufOut ) ) + nOut = DBG_OUT_TESTTOOL; + } + + if ( nOut == DBG_OUT_TESTTOOL ) + { + if ( pData->pDbgPrintTestTool ) + pData->pDbgPrintTestTool( aBufOut ); + else + nOut = DBG_OUT_MSGBOX; + } + + if ( nOut == DBG_OUT_MSGBOX ) + { + if ( pData->pDbgPrintMsgBox ) + pData->pDbgPrintMsgBox( aBufOut ); + else + nOut = DBG_OUT_SHELL; + } + + if ( nOut == DBG_OUT_SHELL ) + { + if ( pData->pDbgPrintShell ) + pData->pDbgPrintShell( aBufOut ); + else + nOut = DBG_OUT_WINDOW; + } + + if ( nOut == DBG_OUT_WINDOW ) + { + if ( pData->pDbgPrintWindow ) + pData->pDbgPrintWindow( aBufOut ); + else + nOut = DBG_OUT_FILE; + } + + if ( nOut == DBG_OUT_FILE ) + ImplDbgPrintFile( aBufOut ); + + ImplDbgUnlock(); + + bIn = FALSE; +} + +// ----------------------------------------------------------------------- + +void DbgOutTypef( USHORT nDbgOut, const sal_Char* pFStr, ... ) +{ + va_list pList; + + va_start( pList, pFStr ); + vsprintf( aBuf, pFStr, pList ); + va_end( pList ); + + DbgOut( aBuf, nDbgOut ); +} + +// ----------------------------------------------------------------------- + +void DbgOutf( const sal_Char* pFStr, ... ) +{ + va_list pList; + + va_start( pList, pFStr ); + vsprintf( aBuf, pFStr, pList ); + va_end( pList ); + + DbgOut( aBuf ); +} + +// ======================================================================= + +#else + +void* DbgFunc( USHORT, void* ) { return NULL; } + +void DbgProf( USHORT, DbgDataType* ) {} +void DbgXtor( DbgDataType*, USHORT, const void*, DbgUsr ) {} + +void DbgOut( const sal_Char*, USHORT, const sal_Char*, USHORT ) {} +void DbgOutTypef( USHORT, const sal_Char*, ... ) {} +void DbgOutf( const sal_Char*, ... ) {} + +#endif diff --git a/tools/source/debug/makefile.mk b/tools/source/debug/makefile.mk new file mode 100644 index 000000000000..c21005fd0331 --- /dev/null +++ b/tools/source/debug/makefile.mk @@ -0,0 +1,89 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=debug + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +CXXFILES= debug.cxx \ + stcktree.cxx + +SLOFILES= $(SLO)$/debug.obj \ + $(SLO)$/stcktree.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/debug.obj \ + $(OBJ)$/stcktree.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/debug/stcktree.cxx b/tools/source/debug/stcktree.cxx new file mode 100644 index 000000000000..3e58510312df --- /dev/null +++ b/tools/source/debug/stcktree.cxx @@ -0,0 +1,351 @@ +/************************************************************************* + * + * $RCSfile: stcktree.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <string.h> + +#include <debug.hxx> + +// ----------------------------------------------------------------------- + +#if defined( DBG_UTIL ) && defined( WNT ) && defined( INTEL ) + +struct ImpDbgStackTree +{ + ImpDbgStackTree* pLeft_; + ImpDbgStackTree* pRight_; + ImpDbgStackTree* pCaller_; + ImpDbgStackTree* pSub_; + ULONG nIP_; + ULONG nBytesLeak_; + ULONG nBytesPeak_; + ULONG nBytes_; + ULONG nCountLeak_; + ULONG nCountPeak_; + ULONG nCount_; + ULONG nMax_; + ULONG nMin_; + + ImpDbgStackTree( ImpDbgStackTree* pSub, ULONG nIP ); + ~ImpDbgStackTree(); + + ImpDbgStackTree* Add( ULONG nAlloc, ULONG* pBP, ULONG nIP ); + void Print( int nLevel, ULONG nCount, ULONG nCountLeak ); + void Print( int nLevel ); +}; + +static ImpDbgStackTree* pImpDbgStackTreeRoot = NULL; +static ULONG* pImpDbgStackTreeBP = NULL; +static ULONG nImpDbgStackTreeMain = 0; +static int nImpDbgStackTreeSem = 0; + +// ----------------------------------------------------------------------- + +ImpDbgStackTree::ImpDbgStackTree( ImpDbgStackTree* pSub, ULONG nIP ) +{ + pSub_ = pSub; + nIP_ = nIP; + pLeft_ = pRight_ = pCaller_ = NULL; + nBytesLeak_ = nBytesPeak_ = nBytes_ = 0; + nCountLeak_ = nCountPeak_ = nCount_ = 0; +} + +// ----------------------------------------------------------------------- + +ImpDbgStackTree::~ImpDbgStackTree() +{ + if ( pLeft_ ) + delete pLeft_; + if ( pRight_ ) + delete pRight_; + if ( pCaller_ ) + delete pCaller_; +} + +// ----------------------------------------------------------------------- + +void ImpDbgStackTree::Print( int nLevel, ULONG nCount, ULONG nCountLeak ) +{ + if ( pLeft_ ) + pLeft_->Print( nLevel, nCount, nCountLeak ); + + if ( nCount_ >= nCount && nCountLeak_ >= nCountLeak ) + { + if ( nMax_ == nMin_ ) + { + ULONG nTemp = nCountLeak_ * nMin_; + DbgOutf( "%*c%08lx Count=%lu/%lu/%lu Bytes=%lu/%lu/%lu Size=%lu", + nLevel, ' ', nIP_, + nCount_, nCountPeak_, nCountLeak_, + nBytes_, nBytesPeak_, nTemp, + nMin_ ); + } + else + { + DbgOutf( "%*c%08lx Count=%lu/%lu/%lu Bytes=%lu/%lu/%lu Size=%lu-%lu", + nLevel, ' ', nIP_, + nCount_, nCountPeak_, nCountLeak_, + nBytes_, nBytesPeak_, nBytesLeak_, + nMin_, nMax_ ); + } + + if ( pCaller_ ) + if( nLevel > 3 && nCountLeak ) + pCaller_->Print( nLevel + 1, nCount, 1 ); + else + pCaller_->Print( nLevel + 1, nCount, nCountLeak ); + } + + if ( pRight_ ) + pRight_->Print( nLevel, nCount, nCountLeak ); +} + +// ----------------------------------------------------------------------- + +void ImpDbgStackTree::Print( int nLevel ) +{ + if ( pSub_ ) + pSub_->Print( nLevel + 1 ); + DbgOutf( "%*c%08lx", nLevel, ' ',nIP_ ); +} + +// ----------------------------------------------------------------------- + +ImpDbgStackTree* ImpDbgStackTree::Add( ULONG nAlloc, ULONG *pBP, ULONG nIP ) +{ + if ( nIP < nIP_ ) + { + if ( !pLeft_ ) + pLeft_ = new ImpDbgStackTree( pSub_, nIP ); + return pLeft_->Add( nAlloc, pBP, nIP ); + } + if ( nIP > nIP_ ) + { + if ( !pRight_ ) + pRight_ = new ImpDbgStackTree( pSub_, nIP ); + return pRight_->Add( nAlloc, pBP, nIP ); + } + + nCount_++; + nCountLeak_++; + if ( nCountLeak_ > nCountPeak_ ) + nCountPeak_ = nCountLeak_; + nBytes_ += nAlloc; + nBytesLeak_ += nAlloc; + if ( nBytesLeak_ > nBytesPeak_ ) + nBytesPeak_ = nBytesLeak_; + if ( nCount_ == 1 ) + nMax_ = nMin_ = nAlloc; + else if ( nMax_ < nAlloc ) + nMax_ = nAlloc; + else if ( nMin_ > nAlloc ) + nMin_ = nAlloc; + + if ( !(pBP[0] & 3) && (ULONG)pBP < pBP[0] && pBP[0] < (ULONG)pImpDbgStackTreeBP ) + { + pBP = (ULONG*)pBP[0]; + nIP = pBP[1]; + if ( 0x01100000 <= nIP && nIP < 0x20000000 && nIP != nImpDbgStackTreeMain ) + { + if ( !pCaller_ ) + pCaller_ = new ImpDbgStackTree( this, nIP ); + return pCaller_->Add( nAlloc, pBP, nIP ); + } + else + return this; + } + + return this; +} + +// ----------------------------------------------------------------------- + +void DbgStartStackTree() +{ + if ( !nImpDbgStackTreeMain ) + { + ULONG* pBP; + __asm mov pBP, ebp; + + pImpDbgStackTreeBP = (ULONG*)pBP[0]; + nImpDbgStackTreeMain = pImpDbgStackTreeBP[1]; + } +} + +// ----------------------------------------------------------------------- + +void DbgEndStackTree() +{ + if ( nImpDbgStackTreeMain ) + { + nImpDbgStackTreeMain = 0; + if ( pImpDbgStackTreeRoot ) + { + // Ausgaben ins File umleiten + DbgData* pData = DbgGetData(); + ULONG nOldOut = pData->nTraceOut; + pData->nTraceOut = DBG_OUT_FILE; + + DbgOutf( "Leak-Report" ); + DbgOutf( "===========" ); + DbgOutf( "Mem-StackTree:" ); + DbgOutf( "{" ); + pImpDbgStackTreeRoot->Print( 1, 1, 2 ); + DbgOutf( "}" ); + + DbgOutf( "Alloc-Report" ); + DbgOutf( "===========" ); + DbgOutf( "Mem-StackTree:" ); + DbgOutf( "{" ); + pImpDbgStackTreeRoot->Print( 1, 1000, 0 ); // ??? + DbgOutf( "}" ); + + pData->nTraceOut = nOldOut; + + nImpDbgStackTreeSem++; + delete pImpDbgStackTreeRoot; + pImpDbgStackTreeRoot = NULL; + nImpDbgStackTreeSem--; + } + } +} + +// ----------------------------------------------------------------------- + +void* DbgGetStackTree( ULONG nAlloc ) +{ + ImpDbgStackTree* pReturn = NULL; + + if ( nImpDbgStackTreeMain && !nImpDbgStackTreeSem ) + { + nImpDbgStackTreeSem++; + + ULONG* pBP; + __asm mov pBP, ebp; + + ULONG nIP = pBP[1]; + if ( !pImpDbgStackTreeRoot ) + pImpDbgStackTreeRoot = new ImpDbgStackTree( NULL, nIP ); + pReturn = pImpDbgStackTreeRoot->Add( nAlloc, pBP, nIP ); + nImpDbgStackTreeSem--; + } + + return pReturn; +} + +// ----------------------------------------------------------------------- + +void DbgFreeStackTree( void* pVoid, ULONG nAlloc ) +{ + ImpDbgStackTree* p = (ImpDbgStackTree*)pVoid; + + if ( p && nImpDbgStackTreeMain && !nImpDbgStackTreeSem ) + { + if ( nAlloc < p->nMin_ ) + nAlloc = p->nMin_; + + p->nCountLeak_--; + p->nBytesLeak_ -= nAlloc; + + if ( p->nMax_ && 0xFFFFFFFF / p->nMax_ > p->nCountLeak_ ) + { + if ( p->nBytesLeak_ > p->nMax_ * p->nCountLeak_ ) + { + nAlloc += p->nBytesLeak_ - p->nMax_ * p->nCountLeak_; + p->nBytesLeak_ = p->nMax_ * p->nCountLeak_; + } + } + + if ( p->pSub_ ) + DbgFreeStackTree( (void*)(p->pSub_), nAlloc ); + } +} + +// ----------------------------------------------------------------------- + +void DbgPrintStackTree( void* pVoid ) +{ + ImpDbgStackTree* p = (ImpDbgStackTree*)pVoid; + + if ( p && nImpDbgStackTreeMain && !nImpDbgStackTreeSem ) + { + // Ausgaben ins File umleiten + DbgData* pData = DbgGetData(); + ULONG nOldOut = pData->nTraceOut; + pData->nTraceOut = DBG_OUT_FILE; + + DbgOutf( "Mem-StackTree:" ); + DbgOutf( "{" ); + p->Print( 1 ); + DbgOutf( "}" ); + + pData->nTraceOut = nOldOut; + } +} + +#else + +void DbgStartStackTree() {} +void DbgEndStackTree() {} +void* DbgGetStackTree( ULONG ) { return NULL; } +void DbgFreeStackTree( void*, ULONG nAlloc ) {} +void DbgPrintStackTree( void* ) {} + +#endif diff --git a/tools/source/fsys/comdep.cxx b/tools/source/fsys/comdep.cxx new file mode 100644 index 000000000000..4bd8d1cc359a --- /dev/null +++ b/tools/source/fsys/comdep.cxx @@ -0,0 +1,116 @@ +/************************************************************************* + * + * $RCSfile: comdep.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifdef MAC +#define private public +#define protected public +#endif + +#include "comdep.hxx" + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _LIST_HXX +#include <list.hxx> +#endif +#ifndef _FSYS_HXX +#include <fsys.hxx> +#endif + +DBG_NAMEEX( DirEntry ); + +//-------------------------------------------------------------------- + +#if defined( DOS ) || defined( WIN ) + +#ifdef MSC +#include "dosmsc.cxx" +#endif + +#if defined( BLC ) || defined( TCPP ) +#include "dosblc.cxx" +#endif + +#ifdef ZTC +#include "dosztc.cxx" +#endif + +#else + +#if defined( WNT ) && !defined( WTC ) +#include "wntmsc.cxx" +#endif + +#ifdef UNX +#include "unx.cxx" +#endif + +#ifdef PM2 +#include "os2.cxx" +#endif + +#ifdef MAC +#include "mac.cxx" +#endif + +#endif + diff --git a/tools/source/fsys/comdep.hxx b/tools/source/fsys/comdep.hxx new file mode 100644 index 000000000000..702548429714 --- /dev/null +++ b/tools/source/fsys/comdep.hxx @@ -0,0 +1,224 @@ +/************************************************************************* + * + * $RCSfile: comdep.hxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _COMDEP_HXX +#define _COMDEP_HXX + +#include "fsys.hxx" + +#define ACCESSDELIM(e) ( (e == FSYS_STYLE_MAC) ? ":" : \ + ( ( e == FSYS_STYLE_VFAT || e == FSYS_STYLE_HPFS || \ + e == FSYS_STYLE_FAT ) || e == FSYS_STYLE_NTFS ) \ + ? "\\" : "/" ) +#define ACCESSDELIM_C(e)(char)\ + ( (e == FSYS_STYLE_MAC) ? ':' : \ + ( ( e == FSYS_STYLE_VFAT || e == FSYS_STYLE_HPFS || \ + e == FSYS_STYLE_FAT ) || e == FSYS_STYLE_NTFS ) \ + ? '\\' : '/' ) +#define SEARCHDELIM(e) ( (e == FSYS_STYLE_SYSV || e == FSYS_STYLE_BSD) ? ":" \ + : ";" ) +#define SEARCHDELIM_C(e)(char)\ + ( (e == FSYS_STYLE_SYSV || e == FSYS_STYLE_BSD) ? ':' \ + : ';' ) +#define ACTPARENT(e) ( (e == FSYS_STYLE_MAC) ? ":" : ".." ) +#define ACTCURRENT(e) ( (e == FSYS_STYLE_MAC) ? "" : "." ) + +#if defined(DOS) || defined(WIN) + +#ifdef MSC +#include "dosmsc.hxx" +#endif + +#if defined(TCPP) || defined(BLC) +#include "dosblc.hxx" +#endif + +#ifdef ZTC +#include "dosztc.hxx" +#endif + +#else + +#if defined( WNT ) && !defined( WTC ) +#include "wntmsc.hxx" +#endif + +#ifdef UNX +#include "unx.hxx" +#endif + +#if defined(PM2) || defined(PM2) +#include "os2.hxx" +#endif + +#ifdef MAC +#include "mac.hxx" +#endif + +#endif + +//-------------------------------------------------------------------- + +#ifndef LINUX +DIR *opendir( const char* pPfad ); +dirent *readdir( DIR *pDir ); +int closedir( DIR *pDir ); +char *volumeid( const char* pPfad ); +#endif + +//-------------------------------------------------------------------- + +struct DirReader_Impl +{ + Dir* pDir; +#ifdef MAC + union + { + DIR* pDosDir; + dirent* pDosEntry; + }; +#else + DIR* pDosDir; + dirent* pDosEntry; +#endif + DirEntry* pParent; + String aPath; + ByteString aBypass; + BOOL bReady; + BOOL bInUse; + + DirReader_Impl( Dir &rDir ) + : pDir( &rDir ), + aPath( GUI2FSYS(rDir.GetFull()) ), + pDosEntry( 0 ), + pParent( 0 ), + bReady ( FALSE ), + bInUse( FALSE ) + { +#ifndef BOOTSTRAP + // Redirection + FSysRedirector::DoRedirect( aPath ); +#endif + + // nur den String der Memer-Var nehmen! + +#ifdef UNX //for further exlpanation see DirReader_Impl::Read() in unx.cxx + pDosDir = NULL; +#else + aBypass = ByteString(aPath, osl_getThreadTextEncoding()); + pDosDir = opendir( (char*) aBypass.GetBuffer() ); +#endif + + // Parent f"ur die neuen DirEntries ermitteln + pParent = pDir->GetFlag() == FSYS_FLAG_NORMAL || + pDir->GetFlag() == FSYS_FLAG_ABSROOT + ? pDir + : pDir->GetParent(); + + } + + ~DirReader_Impl() + { if( pDosDir ) closedir( pDosDir ); } + + // die folgenden sind systemabh"angig implementiert + USHORT Init(); // initialisiert, liest ggf. devices + USHORT Read(); // liest 1 Eintrag, F2ugt ein falls ok +}; + +//-------------------------------------------------------------------- + +struct FileCopier_Impl +{ + FSysAction nActions; // was zu tun ist (Copy/Move/recur) + Link aErrorLink; // bei Fehlern zu rufen + ErrCode eErr; // aktueller Fehlercode im Error-Handler + const DirEntry* pErrSource; // fuer Error-Handler falls Source-Fehler + const DirEntry* pErrTarget; // fuer Error-Handler falls Target-Fehler + + FileCopier_Impl() + : nActions( 0 ), eErr( 0 ), + pErrSource( 0 ), pErrTarget( 0 ) + {} + FileCopier_Impl( const FileCopier_Impl &rOrig ) + : nActions( rOrig.nActions ), eErr( 0 ), + pErrSource( 0 ), pErrTarget( 0 ) + {} + + FileCopier_Impl& operator=( const FileCopier_Impl &rOrig ) + { + nActions = rOrig.nActions; + eErr = 0; pErrSource = 0; pErrTarget = 0; + return *this; + } +}; + +//-------------------------------------------------------------------- + +#if defined(WNT) || defined(OS2) +BOOL IsRedirectable_Impl( const ByteString &rPath ); +#else +#define IsRedirectable_Impl( rPath ) TRUE +#endif + +//-------------------------------------------------------------------- + + +#endif diff --git a/tools/source/fsys/dirent.cxx b/tools/source/fsys/dirent.cxx new file mode 100644 index 000000000000..996be942639e --- /dev/null +++ b/tools/source/fsys/dirent.cxx @@ -0,0 +1,3521 @@ +/************************************************************************* + * + * $RCSfile: dirent.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + + +#if !defined( MAC ) && !defined( UNX ) +#include <io.h> +#endif + +#if defined UNX +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#endif + +#include <ctype.h> +#include <errno.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#if defined (WIN) || defined (MAC) +#include <time.h> +#endif + +#ifdef PM2 +#include <os2.hxx> +#endif + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _LIST_HXX +#include <list.hxx> +#endif + +#ifndef _COMDEP_HXX +#include "comdep.hxx" +#endif +#ifndef _FSYS_HXX +#include "fsys.hxx" +#endif +#define _TOOLS_HXX +#ifndef _URLOBJ_HXX +#include <urlobj.hxx> +#endif + +#ifdef UNX +#define _MAX_PATH 260 +#endif + +#ifdef MAC_UNIVERSAL +#ifndef _UNISTD +#include <unistd.h> +#endif +#endif +#ifdef MAC +#ifndef __ERRORS__ +#include "Errors.h" +#endif +#endif + +#ifndef _STREAM_HXX +#include <stream.hxx> +#endif + +#ifndef _VOS_MUTEX_HXX +#include <vos/mutex.hxx> +#endif + +#include <osl/file.hxx> +using namespace osl; +using namespace rtl; + +int ApiRet2ToSolarError_Impl( int nApiRet ); + +//-------------------------------------------------------------------- +int Sys2SolarError_Impl( int nSysErr ) +{ + switch ( nSysErr ) + { +#ifdef WNT + case NO_ERROR: return ERRCODE_NONE; + case ERROR_INVALID_FUNCTION: return ERRCODE_IO_GENERAL; + case ERROR_FILE_NOT_FOUND: return ERRCODE_IO_NOTEXISTS; + case ERROR_PATH_NOT_FOUND: return ERRCODE_IO_NOTEXISTSPATH; + case ERROR_TOO_MANY_OPEN_FILES: return ERRCODE_IO_TOOMANYOPENFILES; + case ERROR_ACCESS_DENIED: return ERRCODE_IO_ACCESSDENIED; + case ERROR_INVALID_HANDLE: return ERRCODE_IO_GENERAL; + case ERROR_NOT_ENOUGH_MEMORY: return ERRCODE_IO_OUTOFMEMORY; + case ERROR_INVALID_BLOCK: return ERRCODE_IO_GENERAL; +// case ERROR_BAD_ENVIRONMENT: return ERRCODE_IO_; + case ERROR_BAD_FORMAT: return ERRCODE_IO_WRONGFORMAT; + case ERROR_INVALID_ACCESS: return ERRCODE_IO_ACCESSDENIED; +// case ERROR_INVALID_DATA: return ERRCODE_IO_; + case ERROR_INVALID_DRIVE: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_CURRENT_DIRECTORY: return ERRCODE_IO_CURRENTDIR; + case ERROR_NOT_SAME_DEVICE: return ERRCODE_IO_NOTSAMEDEVICE; +// case ERROR_NO_MORE_FILES: return ERRCODE_IO_; + case ERROR_WRITE_PROTECT: return ERRCODE_IO_CANTWRITE; + case ERROR_BAD_UNIT: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_NOT_READY: return ERRCODE_IO_DEVICENOTREADY; + case ERROR_BAD_COMMAND: return ERRCODE_IO_GENERAL; + case ERROR_CRC: return ERRCODE_IO_BADCRC; + case ERROR_BAD_LENGTH: return ERRCODE_IO_INVALIDLENGTH; + case ERROR_SEEK: return ERRCODE_IO_CANTSEEK; + case ERROR_NOT_DOS_DISK: return ERRCODE_IO_WRONGFORMAT; + case ERROR_SECTOR_NOT_FOUND: return ERRCODE_IO_GENERAL; + case ERROR_WRITE_FAULT: return ERRCODE_IO_CANTWRITE; + case ERROR_READ_FAULT: return ERRCODE_IO_CANTREAD; + case ERROR_GEN_FAILURE: return ERRCODE_IO_GENERAL; + case ERROR_SHARING_VIOLATION: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_LOCK_VIOLATION: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_WRONG_DISK: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_NOT_SUPPORTED: return ERRCODE_IO_NOTSUPPORTED; +#else + case 0: return ERRCODE_NONE; + case ENOENT: return ERRCODE_IO_NOTEXISTS; + case EACCES: return ERRCODE_IO_ACCESSDENIED; + case EEXIST: return ERRCODE_IO_ALREADYEXISTS; + case EINVAL: return ERRCODE_IO_INVALIDPARAMETER; + case EMFILE: return ERRCODE_IO_TOOMANYOPENFILES; + case ENOMEM: return ERRCODE_IO_OUTOFMEMORY; + case ENOSPC: return ERRCODE_IO_OUTOFSPACE; +#endif + } + + DBG_TRACE1( "FSys: unknown system error %d occured", nSysErr ); + return FSYS_ERR_UNKNOWN; +} + +//-------------------------------------------------------------------- + +#ifndef BOOTSTRAP + +#if SUPD>=380 +FSysRedirector* FSysRedirector::_pRedirector = 0; +BOOL FSysRedirector::_bEnabled = TRUE; +#ifdef UNX +BOOL bInRedirection = TRUE; +#else +BOOL bInRedirection = FALSE; +#endif +static NAMESPACE_VOS( OMutex )* pRedirectMutex = 0; + +//======================================================================== + +FSysRedirector::~FSysRedirector() +{ +} + +//------------------------------------------------------------------------ +void FSysRedirector::Register( FSysRedirector *pRedirector ) +{ + if ( pRedirector ) + pRedirectMutex = new NAMESPACE_VOS( OMutex ); + else + DELETEZ( pRedirectMutex ); + _pRedirector = pRedirector; +} + +//------------------------------------------------------------------------ + +BOOL FSysRedirector::DoRedirect( String &rPath ) +{ + ByteString aURL(rPath, osl_getThreadTextEncoding()); + + // if redirection is disabled or not even registered do nothing + if ( !_bEnabled || !pRedirectMutex ) + return FALSE; + + // redirect only removable or remote volumes + if ( !IsRedirectable_Impl( aURL ) ) + return FALSE; + + // Redirection is acessible only by one thread per time + // dont move the guard behind the !bInRedirection return FALSE!!! + // think of nested calls (when called from callback) + NAMESPACE_VOS( OGuard ) aGuard( pRedirectMutex ); + + // if already in redirection, dont redirect + if ( bInRedirection ) + return FALSE; + + // dont redirect on nested calls + bInRedirection = TRUE; + + // convert to URL +#ifndef UNX + for ( char *p = (char *) aURL.GetBuffer(); *p; ++p ) +#ifndef MAC + if ( '\\' == *p ) *p = '/'; + else if ( ':' == *p ) *p = '|'; +#else + if ( ':' == *p ) *p = '/'; +#endif +#endif + + aURL.Insert( "file:///", 0 ); + + // do redirection + Redirector(); + BOOL bRedirected = Redirector()->Redirect( String(aURL, osl_getThreadTextEncoding()) ); + + // if redirected transform URL to file name + if ( bRedirected ) + { + rPath = String(aURL.Copy( 8 ), osl_getThreadTextEncoding()); + aURL = ByteString(rPath, osl_getThreadTextEncoding()); +#ifndef UNX + for ( char *p = (char *) aURL.GetBuffer(); *p; ++p ) +#ifndef MAC + if ( '/' == *p ) *p = '\\'; + else if ( '|' == *p ) *p = ':'; +#else + if ( '/' == *p ) *p = ':'; +#endif +#endif + } + + bInRedirection = FALSE; + return bRedirected; +} + +//------------------------------------------------------------------------ + +void FSysRedirector::EnableRedirection( BOOL bEnable ) +{ + if ( !bEnable && pRedirectMutex) + pRedirectMutex->acquire(); + _bEnabled = bEnable; + if ( bEnable && pRedirectMutex) + pRedirectMutex->release(); +} + +//------------------------------------------------------------------------ + +BOOL FSysRedirector::Redirect( String &rPath ) +{ +#ifdef DBG_MI + if ( rPath.Len() && rPath(1) == ':' && + ( rPath(0) == 'b' || rPath(0) == 'B' ) ) + { + rPath(0) = 'd'; + rPath.Insert( "\\mi", 2 ); + return TRUE; + } +#endif + return FALSE; +} + +//------------------------------------------------------------------------ + +FSysRedirector* FSysRedirector::Redirector() +{ + if ( !_pRedirector ) + Register( new FSysRedirector ); + return _pRedirector; +} +#endif + +#endif // BOOTSTRAP + +//-------------------------------------------------------------------- + +class DirEntryStack: public List +{ +public: + DirEntryStack() {}; + ~DirEntryStack(); + + inline void Push( DirEntry *pEntry ); + inline DirEntry* Pop(); + inline DirEntry* Top(); + inline DirEntry* Bottom(); +}; + +inline void DirEntryStack::Push( DirEntry *pEntry ) +{ + List::Insert( pEntry, LIST_APPEND ); +} + +inline DirEntry* DirEntryStack::Pop() +{ + return (DirEntry*) List::Remove( Count() - 1 ); +} + +inline DirEntry* DirEntryStack::Top() +{ + return (DirEntry*) List::GetObject( Count() - 1 ); +} + +inline DirEntry* DirEntryStack::Bottom() +{ + return (DirEntry*) List::GetObject( 0 ); +} + +//-------------------------------------------------------------------- + +DBG_NAME( DirEntry ); + +/************************************************************************* +|* +|* DirEntry::~DirEntryStack() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 04.07.91 +|* +*************************************************************************/ + +DirEntryStack::~DirEntryStack() +{ + while ( Count() ) + delete Pop(); +} + +/************************************************************************* +|* +|* ImpCheckDirEntry() +|* +|* Beschreibung Pruefung eines DirEntry fuer DBG_UTIL +|* Parameter void* p Zeiger auf den DirEntry +|* Return-Wert char* Fehlermeldungs-TExtension oder NULL +|* Ersterstellung MI 16.07.91 +|* Letzte Aenderung MI 26.05.93 +|* +*************************************************************************/ + +#ifdef DBG_UTIL +const char* ImpCheckDirEntry( const void* p ) +{ + DirEntry* p0 = (DirEntry*)p; + + if ( p0->pParent ) + DBG_CHKOBJ( p0->pParent, DirEntry, ImpCheckDirEntry ); + + return NULL; +} +#endif + +/************************************************************************* +|* +|* ImplCutPath() +|* +|* Beschreibung Fuegt ... ein, damit maximal nMaxChars lang +|* Ersterstellung MI 06.04.94 +|* Letzte Aenderung DV 24.06.96 +|* +*************************************************************************/ + +ByteString ImplCutPath( const ByteString& rStr, USHORT nMax, char cAccDel ) +{ + USHORT nMaxPathLen = nMax; + ByteString aCutPath( rStr ); + BOOL bInsertPrefix = FALSE; + USHORT nBegin = aCutPath.Search( cAccDel ); + + if( nBegin == STRING_NOTFOUND ) + nBegin = 0; + else + nMaxPathLen += 2; // fuer Prefix <Laufwerk>: + + while( aCutPath.Len() > nMaxPathLen ) + { + USHORT nEnd = aCutPath.Search( cAccDel, nBegin + 1 ); + USHORT nCount; + + if ( nEnd != STRING_NOTFOUND ) + { + nCount = nEnd - nBegin; + aCutPath.Erase( nBegin, nCount ); + bInsertPrefix = TRUE; + } + else + break; + } + + if ( aCutPath.Len() > nMaxPathLen ) + { + for ( USHORT n = nMaxPathLen; n > nMaxPathLen/2; --n ) + if ( !ByteString(aCutPath.GetChar(n)).IsAlphaNumericAscii() ) + { + aCutPath.Erase( n ); + aCutPath += "..."; + break; + } + } + + if ( bInsertPrefix ) + { + ByteString aIns( cAccDel ); + aIns += "..."; + aCutPath.Insert( aIns, nBegin ); + } + + return aCutPath; +} + +/************************************************************************* +|* +|* DirEntry::ImpParseOs2Name() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 23.06.95 +|* +*************************************************************************/ + +FSysError DirEntry::ImpParseOs2Name( const ByteString& rPfad, FSysPathStyle eStyle ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // die einzelnen Namen auf einen Stack packen + ByteString aPfad( rPfad ); + DirEntryStack aStack; + + do + { + // den Namen vor dem ersten "\\" abspalten, + // falls '\\' am Anfang, ist der Name '\\', + // der Rest immer ohne die fuehrenden '\\'. + // ein ":" trennt ebenfalls, gehoert aber zum Namen + // den ersten '\\', '/' oder ':' suchen + USHORT nPos; + for ( nPos = 0; + nPos < aPfad.Len() && //?O + aPfad.GetChar(nPos) != '\\' && aPfad.GetChar(nPos) != '/' && //?O + aPfad.GetChar(nPos) != ':'; //?O + nPos++ ) + /* do nothing */; + + // ist der Name ein UNC Pathname? + if ( nPos == 0 && aPfad.Len() > 1 && + ( ( aPfad.GetChar(0) == '\\' && aPfad.GetChar(1) == '\\' ) || + ( aPfad.GetChar(0) == '/' && aPfad.GetChar(1) == '/' ) ) ) + { + for ( nPos = 2; aPfad.Len() > nPos; ++nPos ) + if ( aPfad.GetChar(nPos) == '\\' || aPfad.GetChar(nPos) == '/' ) + break; + aName = aPfad.Copy( 2, nPos-2 ); + aStack.Push( new DirEntry( aName, FSYS_FLAG_ABSROOT, eStyle ) ); + } + // ist der Name die Root des aktuellen Drives? + else if ( nPos == 0 && aPfad.Len() > 0 && + ( aPfad.GetChar(0) == '\\' || aPfad.GetChar(0) == '/' ) ) + { + // Root-Directory des aktuellen Drives + aStack.Push( new DirEntry( FSYS_FLAG_ABSROOT ) ); + } + else + { + // ist der Name ein Drive? + if ( nPos < aPfad.Len() && aPfad.GetChar(nPos) == ':' ) + { + aName = aPfad.Copy( 0, nPos + 1 ); + + // ist der Name die Root des Drives + if ( (nPos + 1) < aPfad.Len() && + ( aPfad.GetChar(nPos+1) == '\\' || aPfad.GetChar(nPos+1) == '/' ) ) + { + // schon was auf dem Stack? + // oder Novell-Format? (not supported wegen URLs) + if ( aStack.Count() || aName.Len() > 2 ) + { + aName = rPfad; + return FSYS_ERR_MISPLACEDCHAR; + } + // Root-Directory des Drive + aStack.Push( new DirEntry( aName, FSYS_FLAG_ABSROOT, eStyle ) ); + } + else + { + // liegt ein anderes Drive auf dem Stack? + if ( aStack.Count() && + COMPARE_EQUAL != aStack.Bottom()->aName.CompareIgnoreCaseToAscii(aName) ) + aStack.Clear(); + + // liegt jetzt nichts mehr auf dem Stack? + if ( !aStack.Count() ) + aStack.Push( new DirEntry( aName, FSYS_FLAG_RELROOT, eStyle ) ); + } + } + + // es ist kein Drive + else + { + // den Namen ohne Trenner abspalten + aName = aPfad.Copy( 0, nPos ); + + // stellt der Name die aktuelle Directory dar? + if ( aName == "." ) + /* do nothing */; + + // stellt der Name die Parent-Directory dar? + else if ( aName == ".." ) + { + // ist nichts, ein Parent oder eine relative Root + // auf dem Stack? + if ( ( aStack.Count() == 0 ) || + ( aStack.Top()->eFlag == FSYS_FLAG_PARENT ) || + ( aStack.Top()->eFlag == FSYS_FLAG_RELROOT ) ) + // fuehrende Parents kommen auf den Stack + aStack.Push( new DirEntry( FSYS_FLAG_PARENT ) ); + + // ist es eine absolute Root + else if ( aStack.Top()->eFlag == FSYS_FLAG_ABSROOT ) + { + // die hat keine Parent-Directory + aName = rPfad; + return FSYS_ERR_NOTEXISTS; + } + else + // sonst hebt der Parent den TOS auf + delete aStack.Pop(); + } + + else + { + if ( eStyle == FSYS_STYLE_FAT ) + { + // ist der Name grundsaetzlich ungueltig? + int nPunkte = 0; + const char *pChar; + for ( pChar = aName.GetBuffer(); + nPunkte < 2 && *pChar != 0; + pChar++ ) + { + if ( *pChar == ';' ) + nPunkte = 0; + else + nPunkte += ( *pChar == '.' ) ? 1 : 0; + } + if ( nPunkte > 1 ) + { + aName = rPfad; + return FSYS_ERR_MISPLACEDCHAR; + } + } + + // normalen Entries kommen auf den Stack + DirEntry *pNew = new DirEntry( aName, FSYS_FLAG_NORMAL, eStyle ); + if ( !pNew->IsValid() ) + { + aName = rPfad; + ErrCode eErr = pNew->GetError(); + delete pNew; + return eErr; + } + aStack.Push( pNew ); + } + } + } + + // den Restpfad bestimmen + aPfad.Erase( 0, nPos + 1 ); + while ( aPfad.Len() && ( aPfad.GetChar(0) == '\\' || aPfad.GetChar(0) == '/' ) ) + aPfad.Erase( 0, 1 ); + } + while ( aPfad.Len() ); + + ULONG nErr = ERRCODE_NONE; + // Haupt-Entry (selbst) zuweisen + if ( aStack.Count() == 0 ) + { + eFlag = FSYS_FLAG_CURRENT; + aName.Erase(); + } + else + { + eFlag = aStack.Top()->eFlag; + aName = aStack.Top()->aName; + nErr = aStack.Top()->nError; + delete aStack.Pop(); + } + + // die Parent-Entries vom Stack holen + DirEntry** pTemp = &pParent; // Zeiger auf den Member pParent setzen + while ( aStack.Count() ) + { + *pTemp = aStack.Pop(); + + // Zeiger auf den Member pParent des eigenen Parent setzen + pTemp = &( (*pTemp)->pParent ); + } + + // wird damit ein Volume beschrieben? + if ( !pParent && eFlag == FSYS_FLAG_RELROOT && aName.Len() ) + eFlag = FSYS_FLAG_VOLUME; + + // bei gesetztem ErrorCode den Namen komplett "ubernehmen + if ( nErr ) + aName = rPfad; + return nErr; +} + +/************************************************************************* +|* +|* DirEntry::ImpParseName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.08.91 +|* Letzte Aenderung MI 26.05.93 +|* +*************************************************************************/ + +FSysError DirEntry::ImpParseName( const ByteString& rInitName, + FSysPathStyle eStyle ) +{ + if ( eStyle == FSYS_STYLE_HOST ) + eStyle = DEFSTYLE; + + // KI-Division of FSys + if ( eStyle == FSYS_STYLE_DETECT ) + { + char cFirst = rInitName.Copy(0,1).ToLowerAscii().GetChar(0); + if ( rInitName.Len() == 2 && rInitName.GetChar(1) == ':' && + cFirst >= 'a' && + cFirst <= 'z' ) + eStyle = FSYS_STYLE_HPFS; + else if ( rInitName.Len() > 2 && rInitName.GetChar(1) == ':' ) + { + if ( rInitName.Search( ':', 2 ) == STRING_NOTFOUND ) + eStyle = FSYS_STYLE_HPFS; + else + eStyle = FSYS_STYLE_MAC; + } + else if ( rInitName.Search( '/' ) != STRING_NOTFOUND ) + eStyle = FSYS_STYLE_BSD; + else if ( rInitName.Search( '\\' ) != STRING_NOTFOUND ) + eStyle = FSYS_STYLE_HPFS; + else if ( rInitName.Search( ':' ) != STRING_NOTFOUND ) + eStyle = FSYS_STYLE_MAC; + else + eStyle = FSYS_STYLE_HPFS; + } + + switch ( eStyle ) + { + case FSYS_STYLE_FAT: + case FSYS_STYLE_VFAT: + case FSYS_STYLE_HPFS: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + return ImpParseOs2Name( rInitName, eStyle ); + + case FSYS_STYLE_BSD: + case FSYS_STYLE_SYSV: + return ImpParseUnixName( rInitName, eStyle ); + + case FSYS_STYLE_MAC: + return ImpParseMacName( rInitName ); + + default: + return FSYS_ERR_UNKNOWN; + } +} + +/************************************************************************* +|* +|* GetStyle() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 15.11.91 +|* Letzte Aenderung MI 15.11.91 +|* +*************************************************************************/ + +static FSysPathStyle GetStyle( FSysPathStyle eStyle ) +{ + if ( eStyle == FSYS_STYLE_HOST || eStyle == FSYS_STYLE_DETECT ) + return DEFSTYLE; + else + return eStyle; +} + +/************************************************************************* +|* +|* DirEntry::ImpTrim() +|* +|* Beschreibung bringt den Namen auf Betriebssystem-Norm +|* z.B. 8.3 lower beim MS-DOS Formatter +|* wirkt nicht rekursiv +|* Ersterstellung MI 12.08.91 +|* Letzte Aenderung MI 21.05.92 +|* +*************************************************************************/ + +void DirEntry::ImpTrim( FSysPathStyle eStyle ) +{ + // Wildcards werden nicht geclipt + if ( ( aName.Search( '*' ) != STRING_NOTFOUND ) || + ( aName.Search( '?' ) != STRING_NOTFOUND ) || + ( aName.Search( ';' ) != STRING_NOTFOUND ) ) + return; + + switch ( eStyle ) + { + case FSYS_STYLE_FAT: + { + USHORT nPunktPos = aName.Search( '.' ); + if ( nPunktPos == STRING_NOTFOUND ) + { + if ( aName.Len() > 8 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 8 ); + } + } + else + { + if ( nPunktPos > 8 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 8, nPunktPos - 8 ); + nPunktPos = 8; + } + if ( aName.Len() > nPunktPos + 3 ) + { + if ( aName.Len() - nPunktPos > 4 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( nPunktPos + 4 ); + } + } + } + aName.ToLowerAscii(); + break; + } + + case FSYS_STYLE_VFAT: + case FSYS_STYLE_HPFS: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + if ( aName.Len() > 254 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 254 ); + } + + if ( eStyle == FSYS_STYLE_HPFS && + ( eFlag == FSYS_FLAG_ABSROOT || eFlag == FSYS_FLAG_RELROOT ) ) + aName.ToUpperAscii(); + break; + + case FSYS_STYLE_SYSV: + if ( aName.Len() > 14 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 14 ); + } + break; + + case FSYS_STYLE_BSD: + if ( aName.Len() > 250 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 250 ); + } + break; + + case FSYS_STYLE_MAC: + if ( eFlag & ( FSYS_FLAG_ABSROOT | FSYS_FLAG_VOLUME ) ) + { + if ( aName.Len() > 27 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 27 ); + } + } + else + { + if ( aName.Len() > 31 ) + { + nError = ERRCODE_IO_MISPLACEDCHAR|ERRCODE_WARNING_MASK; + aName.Erase( 31 ); + } + } + break; + + default: + /* kann nicht sein */; + } +} + +/************************************************************************* +|* +|* DirEntry::DirEntry() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry::DirEntry( const ByteString& rName, DirEntryFlag eDirFlag, + FSysPathStyle eStyle ) : +#ifdef FEAT_FSYS_DOUBLESPEED + pStat( 0 ), +#endif + aName( rName ) +{ + DBG_CTOR( DirEntry, ImpCheckDirEntry ); + + pParent = NULL; + eFlag = eDirFlag; + nError = FSYS_ERR_OK; + + ImpTrim( eStyle ); +} + +/************************************************************************* +|* +|* DirEntry::DirEntry() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry::DirEntry( const DirEntry& rOrig ) : +#ifdef FEAT_FSYS_DOUBLESPEED + pStat( rOrig.pStat ? new FileStat(*rOrig.pStat) : 0 ), +#endif + aName( rOrig.aName ) +{ + DBG_CTOR( DirEntry, ImpCheckDirEntry ); + + eFlag = rOrig.eFlag; + nError = rOrig.nError; + + if ( rOrig.pParent ) + { + pParent = new DirEntry( *rOrig.pParent ); + } + else + { + pParent = NULL; + } +} + +/************************************************************************* +|* +|* DirEntry::DirEntry() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry::DirEntry( const String& rInitName, FSysPathStyle eStyle ) +#ifdef FEAT_FSYS_DOUBLESPEED + : pStat( 0 ) +#endif +{ + DBG_CTOR( DirEntry, ImpCheckDirEntry ); + + pParent = NULL; + + // schnelle Loesung fuer Leerstring + if ( !rInitName.Len()) + { + eFlag = FSYS_FLAG_CURRENT; + nError = FSYS_ERR_OK; + return; + } + + ByteString aTmpName(rInitName, osl_getThreadTextEncoding()); + if( eStyle == FSYS_STYLE_URL || aTmpName.CompareIgnoreCaseToAscii("file:",5 ) == COMPARE_EQUAL ) + { +#ifndef BOOTSTRAP + DBG_WARNING( "File URLs are not permitted but accepted" ); + aTmpName = ByteString(INetURLObject( rInitName ).PathToFileName(), osl_getThreadTextEncoding()); + eStyle = FSYS_STYLE_HOST; +#endif // BOOTSTRAP + } + else + { + ::rtl::OUString aTmp; + ::rtl::OUString aOInitName; + if ( FileBase::normalizePath( OUString( rInitName ), aTmp ) == osl_File_E_None ) + { + FileBase::getSystemPathFromNormalizedPath( aTmp, aOInitName ); + aTmpName = ByteString( String(aOInitName), osl_getThreadTextEncoding() ); + } + +#ifdef DBG_UTIL + // ASF nur bei Default eStyle, nicht z.B. aus MakeShortName() + if( eStyle == FSYS_STYLE_HOST && + aTmpName.Search( "://" ) != STRING_NOTFOUND ) + { + ByteString aErr = "DirEntries akzeptieren nur File URLS: "; + aErr += aTmpName; + DBG_WARNING( aErr.GetBuffer() ); + } +#endif + } + + nError = ImpParseName( aTmpName, eStyle ); + + if ( nError != FSYS_ERR_OK ) + eFlag = FSYS_FLAG_INVALID; +} + +/*************************************************************************/ + +DirEntry::DirEntry( const ByteString& rInitName, FSysPathStyle eStyle ) +#ifdef FEAT_FSYS_DOUBLESPEED + : pStat( 0 ) +#endif +{ + DBG_CTOR( DirEntry, ImpCheckDirEntry ); + + pParent = NULL; + + // schnelle Loesung fuer Leerstring + if ( !rInitName.Len() ) + { + eFlag = FSYS_FLAG_CURRENT; + nError = FSYS_ERR_OK; + return; + } + + ByteString aTmpName( rInitName ); + if( eStyle == FSYS_STYLE_URL || rInitName.CompareIgnoreCaseToAscii("file:",5 ) == COMPARE_EQUAL ) + { +#ifndef BOOTSTRAP + DBG_WARNING( "File URLs are not permitted but accepted" ); + aTmpName = ByteString(INetURLObject( rInitName ).PathToFileName(), osl_getThreadTextEncoding()); + eStyle = FSYS_STYLE_HOST; +#endif + } +#ifdef DBG_UTIL + else + // ASF nur bei Default eStyle, nicht z.B. aus MakeShortName() + if( eStyle == FSYS_STYLE_HOST && + rInitName.Search( "://" ) != STRING_NOTFOUND ) + { + ByteString aErr = "DirEntries akzeptieren nur File URLS: "; + aErr += rInitName; + DBG_WARNING( aErr.GetBuffer() ); + } +#endif + + nError = ImpParseName( aTmpName, eStyle ); + + if ( nError != FSYS_ERR_OK ) + eFlag = FSYS_FLAG_INVALID; +} + +/************************************************************************* +|* +|* DirEntry::DirEntry() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry::DirEntry( DirEntryFlag eDirFlag ) +#ifdef FEAT_FSYS_DOUBLESPEED + : pStat( 0 ) +#endif +{ + DBG_CTOR( DirEntry, ImpCheckDirEntry ); + + eFlag = eDirFlag; + nError = ( eFlag == FSYS_FLAG_INVALID ) ? FSYS_ERR_UNKNOWN : FSYS_ERR_OK; + pParent = NULL; +} + +/************************************************************************* +|* +|* DirEntry::~DirEntry() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry::~DirEntry() +{ + DBG_DTOR( DirEntry, ImpCheckDirEntry ); + + delete pParent; +#ifdef FEAT_FSYS_DOUBLESPEED + delete pStat; +#endif + +} + +/************************************************************************* +|* +|* DirEntry::ImpGetTopPtr() const +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +const DirEntry* DirEntry::ImpGetTopPtr() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const DirEntry *pTemp = this; + while ( pTemp->pParent ) + pTemp = pTemp->pParent; + + return pTemp; +} + +/************************************************************************* +|* +|* DirEntry::ImpGetTopPtr() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.11.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry* DirEntry::ImpGetTopPtr() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry *pTemp = this; + while ( pTemp->pParent ) + pTemp = pTemp->pParent; + + return pTemp; +} + +/************************************************************************* +|* +|* DirEntry::ImpGetPreTopPtr() +|* +|* Beschreibung liefert einen Pointer auf den vorletzten Entry +|* Ersterstellung MI 01.11.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry* DirEntry::ImpGetPreTopPtr() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry *pTemp = this; + if ( pTemp->pParent ) + { + while ( pTemp->pParent->pParent ) + pTemp = pTemp->pParent; + } + + return pTemp; +} + +/************************************************************************* +|* +|* DirEntry::ImpChangeParent() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 21.05.92 +|* +*************************************************************************/ + +DirEntry* DirEntry::ImpChangeParent( DirEntry* pNewParent, BOOL bNormalize ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry *pTemp = pParent; + if ( bNormalize && pNewParent && + pNewParent->eFlag == FSYS_FLAG_RELROOT && !pNewParent->aName.Len() ) + { + pParent = 0; + delete pNewParent; + } + else + pParent = pNewParent; + + return pTemp; +} + +/************************************************************************* +|* +|* DirEntry::Exists() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 24.09.91 +|* +*************************************************************************/ + +BOOL DirEntry::Exists( FSysAccess nAccess ) const +{ +#ifndef BOOTSTRAP + static NAMESPACE_VOS(OMutex) aLocalMutex; + NAMESPACE_VOS(OGuard) aGuard( aLocalMutex ); +#endif + if ( !IsValid() ) + return FALSE; + +#if defined(DOS) || defined(WIN) || defined(WNT) || defined(OS2) + // spezielle Filenamen sind vom System da + if ( ( aName.CompareIgnoreCaseToAscii("CLOCK$") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("CON") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("AUX") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("COM1") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("COM2") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("COM3") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("COM4") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("LPT1") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("LPT2") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("LPT3") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("NUL") == COMPARE_EQUAL || + aName.CompareIgnoreCaseToAscii("PRN") == COMPARE_EQUAL ) ) + return TRUE; +#endif + + FSysFailOnErrorImpl(); + DirEntryKind eKind = FileStat( *this, nAccess ).GetKind(); + if ( eKind & ( FSYS_KIND_FILE | FSYS_KIND_DIR ) ) + { + return TRUE; + } + +#if defined(WIN) || defined(DOS) || defined(OS2) || defined(WNT) + if ( 0 != ( eKind & FSYS_KIND_DEV ) ) + { + return DRIVE_EXISTS( ImpGetTopPtr()->aName.GetChar(0) ); + } +#endif + + return 0 != ( eKind & ( FSYS_KIND_FILE | FSYS_KIND_DIR ) ); +} + +/************************************************************************* +|* +|* DirEntry::First() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 15.01.92 +|* +*************************************************************************/ + +BOOL DirEntry::First() +{ + FSysFailOnErrorImpl(); + + String aUniPathName( GetPath().GetFull() ); +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect( aUniPathName ); + ByteString aPathName(aUniPathName, osl_getThreadTextEncoding()); +#else + ByteString aPathName(aUniPathName, gsl_getSystemTextEncoding()); +#endif + aPathName = GUI2FSYS( aPathName ); + + DIR *pDir = opendir( (char*) aPathName.GetBuffer() ); + if ( pDir ) + { +#ifndef BOOTSTRAP + WildCard aWildeKarte( String(CMP_LOWER( aName ), osl_getThreadTextEncoding()) ); +#else + WildCard aWildeKarte( String(CMP_LOWER( aName ), gsl_getSystemTextEncoding()) ); +#endif + for ( dirent* pEntry = readdir( pDir ); + pEntry; + pEntry = readdir( pDir ) ) + { + ByteString aFound( FSYS2GUI( ByteString( pEntry->d_name ) ) ); + if ( aWildeKarte.Matches( String(CMP_LOWER( aFound ), osl_getThreadTextEncoding()))) + { + aName = aFound; + closedir( pDir ); + return TRUE; + } + } + closedir( pDir ); + } + return FALSE; +} + +/************************************************************************* +|* +|* DirEntry::GetFull() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +String DirEntry::GetFull( FSysPathStyle eStyle, BOOL bWithDelimiter, + USHORT nMaxChars ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + ByteString aRet; + eStyle = GetStyle( eStyle ); + if ( pParent ) + { + if ( ( pParent->eFlag == FSYS_FLAG_ABSROOT || + pParent->eFlag == FSYS_FLAG_RELROOT || + pParent->eFlag == FSYS_FLAG_VOLUME ) ) + { + aRet = ByteString(pParent->GetName( eStyle ), osl_getThreadTextEncoding()); + aRet += ByteString(GetName( eStyle ), osl_getThreadTextEncoding()); + } + else + { + aRet = ByteString(pParent->GetFull( eStyle ), osl_getThreadTextEncoding()); + aRet += ACCESSDELIM_C(eStyle); + aRet += ByteString(GetName( eStyle ), osl_getThreadTextEncoding()); + } + } + else + { + aRet = ByteString(GetName( eStyle ), osl_getThreadTextEncoding()); + } + + if ( ( eStyle == FSYS_STYLE_MAC ) && + ( ImpGetTopPtr()->eFlag != FSYS_FLAG_VOLUME ) && + ( ImpGetTopPtr()->eFlag != FSYS_FLAG_ABSROOT ) && + ( aRet.GetChar(0) != ':' ) ) + aRet.Insert( ACCESSDELIM_C(eStyle), 0 ); + + //! Hack + if ( bWithDelimiter ) + if ( aRet.GetChar( aRet.Len()-1 ) != ACCESSDELIM_C(eStyle) ) + aRet += ACCESSDELIM_C(eStyle); + + //! noch ein Hack + if ( nMaxChars < STRING_MAXLEN ) + aRet = ImplCutPath( aRet, nMaxChars, ACCESSDELIM_C(eStyle) ); + + return String(aRet, osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* DirEntry::GetPath() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry DirEntry::GetPath() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( pParent ) + return DirEntry( *pParent ); + + return DirEntry(); +} + +/************************************************************************* +|* +|* DirEntry::GetExtension() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +String DirEntry::GetExtension( char cSep ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const char *p0 = ( aName.GetBuffer() ); + const char *p1 = p0 + aName.Len() - 1; + while ( p1 >= p0 && *p1 != cSep ) + p1--; + + if ( p1 >= p0 ) + // es wurde ein cSep an der Position p1 gefunden + return String(aName.Copy( p1 - p0 + 1 ), osl_getThreadTextEncoding()); + return String(); +} + +/************************************************************************* +|* +|* DirEntry::GetBase() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +String DirEntry::GetBase( char cSep ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const char *p0 = ( aName.GetBuffer() ); + const char *p1 = p0 + aName.Len() - 1; + while ( p1 >= p0 && *p1 != cSep ) + p1--; + + if ( p1 >= p0 ) + // es wurde ein cSep an der Position p1 gefunden + return String(aName.Copy( 0, p1 - p0 ), osl_getThreadTextEncoding()); + + else + // es wurde kein cSep gefunden + return String(aName, osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* DirEntry::GetName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 13:47 +|* +*************************************************************************/ + +String DirEntry::GetName( FSysPathStyle eStyle ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + ByteString aRet; + eStyle = GetStyle( eStyle ); + + switch( eFlag ) + { + case FSYS_FLAG_PARENT: + aRet = ACTPARENT(eStyle); + break; + + case FSYS_FLAG_ABSROOT: + { + if ( eStyle == FSYS_STYLE_URL ) + { + aRet = "file:///"; + aRet += aName; + +#ifndef UNX + if ( aName.Len()) + { + if ( aName.GetChar(aName.Len()-1) == ':' ) + { + aRet.SetChar(aRet.Len()-1, '|'); + } + else + { +#ifndef MAC + aRet.Insert( '/', 5 ); +#endif + } + aRet += "/"; + } +#endif + } + else if ( eStyle != FSYS_STYLE_MAC && + aName.Len() > 1 && aName.GetChar( 1 ) != ':' ) + { + // UNC-Pathname + aRet = ACCESSDELIM_C(eStyle); + aRet += ACCESSDELIM_C(eStyle); + aRet += aName ; + aRet += ACCESSDELIM_C(eStyle); + } + else + { + aRet = aName; + aRet += ACCESSDELIM_C(eStyle); + } + break; + } + + case FSYS_FLAG_INVALID: + case FSYS_FLAG_VOLUME: + { + if ( eStyle == FSYS_STYLE_URL ) + { + aRet = "file:///"; + aRet += aName; +#ifndef UNX + if ( aName.Len() && aName.GetChar(aName.Len()-1) == ':' ) + { + aRet.SetChar(aRet.Len()-1, '|'); + } +#endif + } + else + { + aRet = aName; + } + + break; + } + + case FSYS_FLAG_RELROOT: + if ( !aName.Len() ) + { + aRet = ACTCURRENT(eStyle); + break; + } + + default: + aRet = aName; + } + + return String(aRet, osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* DirEntry::IsAbs() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +BOOL DirEntry::IsAbs() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + +#ifdef UNX + return ( pParent ? pParent->IsAbs() : eFlag == FSYS_FLAG_ABSROOT ); +#else + return ( pParent ? pParent->IsAbs() : eFlag == FSYS_FLAG_ABSROOT && aName.Len() > 0 ); +#endif +} + +/************************************************************************* +|* +|* DirEntry::CutName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +String DirEntry::CutName( FSysPathStyle eStyle ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + eStyle = GetStyle( eStyle ); + + String aOldName( GetName( eStyle ) ); + + if ( pParent ) + { + DirEntry *pOldParent = pParent; + if ( pOldParent ) + { + pParent = pOldParent->pParent; + eFlag = pOldParent->eFlag; + aName = pOldParent->aName; + pOldParent->pParent = NULL; + delete pOldParent; + } + else + { + eFlag = FSYS_FLAG_CURRENT; + aName.Erase(); + } + } + else + { + eFlag = FSYS_FLAG_CURRENT; + aName.Erase(); + delete pParent; + pParent = NULL; + } + + return aOldName; +} + +/************************************************************************* +|* +|* DirEntry::NameCompare +|* +|* Beschreibung Vergleich nur die Namen (ohne Pfad, aber mit Gross/Klein) +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +StringCompare DirEntry::NameCompare( const DirEntry &rWith ) const +{ + ByteString aThisName; + ByteString aParameterName; + +#ifdef UNX + aThisName = aName; + aParameterName = rWith.aName; +#else + aThisName = ByteString(aName).ToLowerAscii(); + aParameterName = ByteString(rWith.aName).ToLowerAscii(); +#endif + + return aThisName.CompareTo( aParameterName ); +} + + +/************************************************************************* +|* +|* DirEntry::operator==() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +BOOL DirEntry::operator==( const DirEntry& rEntry ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // test wheather the contents are textual the same + + if ( nError && ( nError == rEntry.nError ) ) + return TRUE; + if ( nError || rEntry.nError || + ( eFlag == FSYS_FLAG_INVALID ) || + ( rEntry.eFlag == FSYS_FLAG_INVALID ) ) + return FALSE; + + const DirEntry *pThis = this; + const DirEntry *pWith = &rEntry; + while( pThis && pWith && (pThis->eFlag == pWith->eFlag) ) + { + if ( CMP_LOWER(pThis->aName) != CMP_LOWER(pWith->aName) ) + break; + pThis = pThis->pParent; + pWith = pWith->pParent; + } + + return ( !pThis && !pWith ); +} + +/************************************************************************* +|* +|* DirEntry::operator=() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry& DirEntry::operator=( const DirEntry& rEntry ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( this == &rEntry ) + return *this; + if ( rEntry.nError != FSYS_ERR_OK ) { + DBG_ERROR("Zuweisung mit invalidem DirEntry"); + nError = rEntry.nError; + return *this; + } + + // Name und Typ uebernehmen, Refs beibehalten + aName = rEntry.aName; + eFlag = rEntry.eFlag; + nError = FSYS_ERR_OK; + + DirEntry *pOldParent = pParent; + if ( rEntry.pParent ) + pParent = new DirEntry( *rEntry.pParent ); + else + pParent = NULL; + + if ( pOldParent ) + delete pOldParent; + return *this; +} + +/************************************************************************* +|* +|* DirEntry::operator+() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry DirEntry::operator+( const DirEntry& rEntry ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); +#ifdef DBG_UTIL + static BOOL bTested = FALSE; + if ( !bTested ) + { + bTested = TRUE; + FSysTest(); + } +#endif + + const DirEntry *pEntryTop = rEntry.ImpGetTopPtr(); + const DirEntry *pThisTop = ImpGetTopPtr(); + + // "." + irgendwas oder irgendwas + "d:irgendwas" +/* TPF:org + if ( ( eFlag == FSYS_FLAG_RELROOT && !aName ) || + ( pEntryTop->aName.Len() && + ( pEntryTop->eFlag == FSYS_FLAG_ABSROOT || + pEntryTop->eFlag == FSYS_FLAG_RELROOT || + pEntryTop->eFlag == FSYS_FLAG_VOLUME ) ) ) + return rEntry; +*/ + + if ( + (eFlag == FSYS_FLAG_RELROOT && !aName.Len()) || + ( + (pEntryTop->aName.Len() || + ((rEntry.Level()>1)?(rEntry[rEntry.Level()-2].aName.CompareIgnoreCaseToAscii(RFS_IDENTIFIER)==COMPARE_EQUAL):FALSE)) + && + (pEntryTop->eFlag == FSYS_FLAG_ABSROOT || + pEntryTop->eFlag == FSYS_FLAG_RELROOT || + pEntryTop->eFlag == FSYS_FLAG_VOLUME) + ) + ) + { + return rEntry; + } + + // irgendwas + "." (=> pEntryTop == &rEntry) + if ( pEntryTop->eFlag == FSYS_FLAG_RELROOT && !pEntryTop->aName.Len() ) + { + DBG_ASSERT( pEntryTop == &rEntry, "DirEntry::op+ buggy" ); + return *this; + } + + // root += ".." (=> unmoeglich) + if ( pEntryTop->eFlag == FSYS_FLAG_PARENT && pThisTop == this && + ( eFlag == FSYS_FLAG_ABSROOT ) ) + return DirEntry( FSYS_FLAG_INVALID ); + + // irgendwas += abs (=> nur Device uebernehmen falls vorhanden) + if ( pEntryTop->eFlag == FSYS_FLAG_ABSROOT ) + { + ByteString aDevice; + if ( pThisTop->eFlag == FSYS_FLAG_ABSROOT ) + aDevice = pThisTop->aName; + DirEntry aRet = rEntry; + if ( aDevice.Len() ) + aRet.ImpGetTopPtr()->aName = aDevice; + return aRet; + } + + // irgendwas += ".." (=> aufloesen) + if ( eFlag == FSYS_FLAG_NORMAL && pEntryTop->eFlag == FSYS_FLAG_PARENT ) + { + String aConcated( GetFull() ); + aConcated += ACCESSDELIM_C(FSYS_STYLE_HOST); + aConcated += rEntry.GetFull(); + return DirEntry( aConcated ); + } + + // sonst einfach hintereinander haengen + DirEntry aRet( rEntry ); + DirEntry *pTop = aRet.ImpGetTopPtr(); + pTop->pParent = new DirEntry( *this ); + + return aRet; +} + +/************************************************************************* +|* +|* DirEntry::operator+=() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +DirEntry &DirEntry::operator+=( const DirEntry& rEntry ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + return *this = *this + rEntry; +} + +/************************************************************************* +|* +|* DirEntry::GetAccessDelimiter() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 27.05.93 +|* Letzte Aenderung MI 10.06.93 +|* +*************************************************************************/ + +String DirEntry::GetAccessDelimiter( FSysPathStyle eFormatter ) +{ + return String( ACCESSDELIM_C( GetStyle( eFormatter ) ) ); +} + +/************************************************************************* +|* +|* DirEntry::SetExtension() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 02.08.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +void DirEntry::SetExtension( const String& rExtension, char cSep ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // do not set extensions for drives + if(eFlag == FSYS_FLAG_ABSROOT) + { + nError = FSYS_ERR_NOTSUPPORTED; + return; + } + + // cSep im Namen suchen + const char *p0 = ( aName.GetBuffer() ); + const char *p1 = p0 + aName.Len() - 1; + while ( p1 >= p0 && *p1 != cSep ) + p1--; + if ( p1 >= p0 ) + { + // es wurde ein cSep an der Position p1 gefunden + aName.Erase( p1 - p0 + 1 - ( rExtension.Len() ? 0 : 1 ) ); + aName += ByteString(rExtension, osl_getThreadTextEncoding()); + } + else if ( rExtension.Len() ) + { + // es wurde kein cSep gefunden + aName += cSep; + aName += ByteString(rExtension, osl_getThreadTextEncoding()); + } +} + +/************************************************************************* +|* +|* DirEntry::CutExtension() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 23.07.93 +|* Letzte Aenderung MI 23.07.93 +|* +*************************************************************************/ + +String DirEntry::CutExtension( char cSep ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const char *p0 = ( aName.GetBuffer() ); + const char *p1 = p0 + aName.Len() - 1; + while ( p1 >= p0 && *p1 != cSep ) + p1--; + + if ( p1 >= p0 ) + { + // es wurde ein cSep an der Position p1 gefunden + aName.Erase( p1-p0 ); + return String(p1 + 1, osl_getThreadTextEncoding()); + } + + return String(); +} + +/************************************************************************* +|* +|* DirEntry::SetName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 04.09.93 +|* Letzte Aenderung MI 04.09.93 +|* +*************************************************************************/ + +void DirEntry::SetName( const String& rName, FSysPathStyle eFormatter ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( eFormatter == FSYS_STYLE_HOST || eFormatter == FSYS_STYLE_DETECT ) + eFormatter = DEFSTYLE; + ByteString aAccDelim( ACCESSDELIM_C( eFormatter ) ); + + if ( (eFlag != FSYS_FLAG_NORMAL) || + (aName.Search( ':' ) != STRING_NOTFOUND) || + (aName.Search( aAccDelim ) != STRING_NOTFOUND) || + (eFormatter == FSYS_STYLE_FAT && (aName.GetTokenCount( '.' ) > 2) ) ) + { + eFlag = FSYS_FLAG_INVALID; + } + else + { + aName = ByteString(rName, osl_getThreadTextEncoding()); + } +} + +/************************************************************************* +|* +|* DirEntry::Find() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ +#if SUPD<=381 +BOOL DirEntry::Find( const String& rPfad ) +{ + return Find( rPfad, SEARCHDELIM(DEFSTYLE)[0] ); +} +#endif + +BOOL DirEntry::Find( const String& rPfad, char cDelim ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( ImpGetTopPtr()->eFlag == FSYS_FLAG_ABSROOT ) + return TRUE; + + BOOL bWild = aName.Search( '*' ) != STRING_NOTFOUND || + aName.Search( '?' ) != STRING_NOTFOUND; + if ( !cDelim ) + cDelim = SEARCHDELIM(DEFSTYLE)[0]; + + USHORT nTokenCount = rPfad.GetTokenCount( cDelim ); + USHORT nIndex = 0; +#ifndef MAC + ByteString aThis = ACCESSDELIM(DEFSTYLE); + aThis += ByteString(GetFull(), osl_getThreadTextEncoding()); +#else + String aThis(GetFull(), osl_getThreadTextEncoding()); +#endif + for ( USHORT nToken = 0; nToken < nTokenCount; ++nToken ) + { + ByteString aPath = ByteString(rPfad, osl_getThreadTextEncoding()).GetToken( 0, cDelim, nIndex ); +#ifdef MAC + if (aPath[aPath.Len()-1] == ':') + aPath.Cut(aPath.Len()-1); +#endif + aPath += aThis; + DirEntry aEntry( String(aPath, osl_getThreadTextEncoding())); + if ( aEntry.ToAbs() && + ( ( !bWild && aEntry.Exists() ) || ( bWild && aEntry.First() ) ) ) + { + (*this) = aEntry; + return TRUE; + } + } + return FALSE; +} + +/************************************************************************* +|* +|* DirEntry::ImpToRel() +|* +|* Beschreibung +|* Ersterstellung MI 17.06.93 +|* Letzte Aenderung MI 17.06.93 +|* +*************************************************************************/ + +BOOL DirEntry::ImpToRel( String aCurStr ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aThis(*this); + aThis.ToAbs(); + ByteString aThisStr( aThis.GetFull( FSYS_STYLE_HPFS ), osl_getThreadTextEncoding()); + ByteString bCurStr( aCurStr, osl_getThreadTextEncoding()); + aThisStr = CMP_LOWER( aThisStr ); + bCurStr = CMP_LOWER( bCurStr ); + + // "Ubereinstimmung pr"ufen + USHORT nPos = aThisStr.Match( bCurStr ); + if ( nPos == STRING_MATCH && aThisStr.Len() != bCurStr.Len() ) + nPos = Min( aThisStr.Len(), bCurStr.Len() ); + + // Sonderfall, die DirEntries sind identisch + if ( nPos == STRING_MATCH ) + { + // dann ist der relative Pfad das aktuelle Verzeichnis + *this = DirEntry(); + return TRUE; + } + + // Sonderfall, die DirEntries sind total verschieden + if ( nPos == 0 ) + { + // dann ist der relativste Pfad absolut + *this = aThis; + return FALSE; + } + + // sonst nehmen wir die identischen Einzelteile vorne weg + while ( nPos > 0 && aThisStr.GetChar(nPos) != '\\' ) + --nPos; + aThisStr.Erase( 0, nPos + ( ( aThisStr.GetChar(nPos) == '\\' ) ? 1 : 0 ) ); + bCurStr.Erase( 0, nPos + ( ( bCurStr.GetChar(nPos) == '\\' ) ? 1 : 0 ) ); + + // und fuellen mit dem Level der Directories auf + for ( nPos = 0; nPos < bCurStr.Len(); ++nPos ) + if ( bCurStr.GetChar(nPos) == '\\' ) + aThisStr.Insert( "..\\", 0 ); + + // das ist dann unser relativer Pfad + *this = DirEntry( String(aThisStr, osl_getThreadTextEncoding()), FSYS_STYLE_HPFS ); + return TRUE; +} + +/************************************************************************* +|* +|* DirEntry::CutRelParents() +|* +|* Beschreibung +|* Ersterstellung MI 01.08.95 +|* Letzte Aenderung MI 01.08.95 +|* +*************************************************************************/ + +USHORT DirEntry::CutRelParents() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // erstes '..' finden + DirEntry *pDir = 0; + DirEntry *pPar; + + for ( pPar = this; + pPar && pPar->eFlag != FSYS_FLAG_PARENT; + pPar = pPar->pParent ) + pDir = pPar; + + // '..' zaehlen + USHORT nParCount = 0; + while ( pPar && pPar->eFlag == FSYS_FLAG_PARENT ) + { + ++nParCount; + pPar = pPar->pParent; + } + + // cutten + if ( pDir ) + DELETEZ(pDir->pParent); + else + eFlag = FSYS_FLAG_CURRENT; + + return nParCount; +} + +/************************************************************************* +|* +|* DirEntry::ToRel() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.06.93 +|* Letzte Aenderung MI 17.06.93 +|* +*************************************************************************/ + +BOOL DirEntry::ToRel() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aCur; + aCur.ToAbs(); + return ImpToRel( aCur.GetFull( FSYS_STYLE_HPFS ) ); +} + +/************************************************************************* +|* +|* DirEntry::ToRel() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +BOOL DirEntry::ToRel( const DirEntry& rStart ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aStart( rStart ); + aStart.ToAbs(); + return ImpToRel( aStart.GetFull( FSYS_STYLE_HPFS ) ); +} + +/************************************************************************* +|* +|* DirEntry::GetDevice() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +#ifndef UNX + +DirEntry DirEntry::GetDevice() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const DirEntry *pTop = ImpGetTopPtr(); + + if ( ( pTop->eFlag == FSYS_FLAG_ABSROOT || pTop->eFlag == FSYS_FLAG_RELROOT ) && + pTop->aName.Len() ) + return DirEntry( pTop->aName, FSYS_FLAG_VOLUME, FSYS_STYLE_HOST ); + else + return DirEntry( ByteString(), FSYS_FLAG_INVALID, FSYS_STYLE_HOST ); +} + +#endif + +/************************************************************************* +|* +|* DirEntry::SetBase() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 23.10.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +void DirEntry::SetBase( const String& rBase, char cSep ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const char *p0 = ( aName.GetBuffer() ); + const char *p1 = p0 + aName.Len() - 1; + while ( p1 >= p0 && *p1 != cSep ) + p1--; + + if ( p1 >= p0 ) + { + // es wurde ein cSep an der Position p1 gefunden + aName.Erase( 0, p1 - p0 ); + aName.Insert( ByteString(rBase, osl_getThreadTextEncoding()), 0 ); + } + else + aName = ByteString(rBase, osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* DirEntry::GetSearchDelimiter() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 10.06.93 +|* Letzte Aenderung MI 10.06.93 +|* +*************************************************************************/ + +String DirEntry::GetSearchDelimiter( FSysPathStyle eFormatter ) +{ + return String( ByteString(SEARCHDELIM( GetStyle( eFormatter ) ) ), osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* DirEntry::GetMaxNameLen() +|* +|* Beschreibung Liefert die maximale Anzahl von Zeichen in +|* einzelnen Namensteile. Bei FileSystmen mit +|* fester Extension (FAT) zaehlt diese nicht mit. +|* Bei unbekannten FileSytemen und FSYS_STYLE_URL +|* wird USHRT_MAX zurueckgegeben. +|* Ersterstellung MI 17.06.97 +|* Letzte Aenderung MI 17.06.97 +|* +*************************************************************************/ + +USHORT DirEntry::GetMaxNameLen( FSysPathStyle eFormatter ) +{ + eFormatter = GetStyle( eFormatter ); + switch ( eFormatter ) + { + case FSYS_STYLE_MAC: return 31; + + case FSYS_STYLE_FAT: return 8; + + case FSYS_STYLE_VFAT: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + case FSYS_STYLE_HPFS: return 255; + + + case FSYS_STYLE_SYSV: return 14; + + case FSYS_STYLE_BSD: return 250; + } + + return USHRT_MAX; +} + +/************************************************************************* +|* +|* DirEntry::TempName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung VB 06.09.93 (im SWG) +|* Letzte Aenderung MI 06.02.98 +|* +*************************************************************************/ + +DirEntry aTempNameBase_Impl; + +const DirEntry& DirEntry::SetTempNameBase( const String &rBase ) +{ + DirEntry aTempDir = DirEntry().TempName().GetPath(); + aTempDir += DirEntry( rBase ); +#ifdef UNX + ByteString aName( aTempDir.GetFull(), osl_getThreadTextEncoding()); + if ( access( aName.GetBuffer(), W_OK | X_OK | R_OK ) ) + { + aTempDir.MakeDir(); + chmod( aName.GetBuffer(), S_IRWXU | S_IRWXG | S_IRWXO ); + } +#else + aTempDir.MakeDir(); +#endif + aTempNameBase_Impl = aTempDir.TempName( FSYS_KIND_DIR ); + return aTempNameBase_Impl; +} + +DirEntry DirEntry::TempName( DirEntryKind eKind ) const +{ + // ggf. Base-Temp-Dir verwenden (macht Remote keinen Sinn => vorher) + if ( !pParent && FSYS_FLAG_CURRENT != aTempNameBase_Impl.eFlag && FSYS_FLAG_ABSROOT != eFlag ) + + { + DirEntry aFactory( aTempNameBase_Impl ); + aFactory += GetName(); + return aFactory.TempName(); + } + +#ifdef OS2 + // + // resolves long FAT names used by OS2 + // + if (Folder::IsAvailable() && IsLongNameOnFAT()) + { + // in DirEntry mit kurzem Pfad wandeln + ItemIDPath aItemIDPath(GetFull()); + String aString(aItemIDPath.GetHostNotationPath()); + DirEntry aDirEntry(aString); + + // Aufruf der Methode + return aDirEntry.TempName(eKind); + } +#endif + + ByteString aDirName; // hiermit hatte MPW C++ Probleme - immmer noch?? + char *ret_val; + size_t i; + + // dertermine Directory, Prefix and Extension + char pfx[6]; + char ext[5]; + const char *dir; + const char *pWild = strchr( aName.GetBuffer(), '*' ); + if ( !pWild ) + pWild = strchr( aName.GetBuffer(), '?' ); + + if ( pWild ) + { + if ( pParent ) + aDirName = ByteString(pParent->GetFull(), osl_getThreadTextEncoding()); + strncpy( pfx, aName.GetBuffer(), Min( (int)5, (int)(pWild-aName.GetBuffer()) ) ); + pfx[ pWild-aName.GetBuffer() ] = 0; + const char *pExt = strchr( pWild, '.' ); + if ( pExt ) + { + strncpy( ext, pExt, 4 ); + ext[4] = 0; + } + else + strcpy( ext, ".tmp" ); + } + else + { + aDirName = ByteString(GetFull(), osl_getThreadTextEncoding()); + strcpy( pfx, "sv" ); + strcpy( ext, ".tmp" ); + } + dir = aDirName.GetBuffer(); + + // wurde kein Dir angegeben, dann nehmen wir ein passendes TEMP-Verz. + char sBuf[_MAX_PATH]; + if ( eFlag == FSYS_FLAG_CURRENT || ( !pParent && pWild ) ) + dir = TempDirImpl(sBuf); + + // ab hier leicht modifizierter Code von VB + DirEntry aRet(FSYS_FLAG_INVALID); + i = strlen(dir); + // need to add ?\\? + prefix + number + .ext + '\0' + // please note that number is of length 5 not 3 +# define TMPNAME_SIZE ( 1 + 5 + 5 + 4 + 1 ) + ret_val = new char[i + TMPNAME_SIZE ]; + if (ret_val) + { + strcpy(ret_val,dir); + + /* Make sure directory ends with a separator */ +#if defined(DOS) || defined(PM2) || defined(WIN) || defined(WNT) + if ( i>0 && ret_val[i-1] != '\\' && ret_val[i-1] != '/' && + ret_val[i-1] != ':') + ret_val[i++] = '\\'; +#elif (UNX) + if (i>0 && ret_val[i-1] != '/') + ret_val[i++] = '/'; +#elif (MAC) + if (i>0 && ret_val[i-1] != ':') + ret_val[i++] = ':'; +#else +#error unknown operating system +#endif + + strncpy(ret_val + i, pfx, 5); + ret_val[i + 5] = '\0'; /* strncpy doesn't put a 0 if more */ + i = strlen(ret_val); /* than 'n' chars. */ + + /* Prefix can have 5 chars, leaving 3 for numbers. + 26 ** 3 == 17576 + */ +#if (defined (MSC) || defined (BLC) || defined(ICC) ) && ( defined (WIN) || defined (WNT)) + static unsigned long u = GetTickCount(); +#else + static unsigned long u = clock(); +#endif + for ( unsigned long nOld = u; ++u != nOld; ) + { + u %= (26*26*26); + unsigned nTemp = (unsigned)u; +#if defined(OS2) || defined(WIN) || defined(WNT) || defined(DOS) + itoa(nTemp,ret_val + i,26); +#else + // the number needs length 5 not 3 !!!! + sprintf(ret_val+i, "%03u", nTemp); +#endif + strcat(ret_val,ext); + + if ( FSYS_KIND_FILE == eKind ) + { + SvFileStream aStream( String( ret_val, osl_getThreadTextEncoding()), + STREAM_WRITE|STREAM_SHARE_DENYALL ); + if ( aStream.IsOpen() ) + { + aStream.Seek( STREAM_SEEK_TO_END ); + if ( 0 == aStream.Tell() ) + { + aRet = DirEntry( String( ret_val, osl_getThreadTextEncoding())); + break; + } + aStream.Close(); + } + } + else + { + // Redirect + String aRetVal(ret_val, osl_getThreadTextEncoding()); + String aRedirected (aRetVal); +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect( aRedirected ); +#endif + if ( FSYS_KIND_DIR == eKind ) + { + if ( 0 == _mkdir( ByteString(aRedirected.GetBuffer(), osl_getThreadTextEncoding()).GetBuffer() ) ) + { + aRet = DirEntry( aRetVal ); + break; + } + } + else + { +#if defined(MAC) + OSErr nErr; + FSSpec aFSSpec; + FInfo dummyFInfo; + + nErr = FSMakeFSSpec( 0, 0, aRedirected.GetPascalStr(), &aFSSpec ); + if (nErr == noErr) + nErr = FSpGetFInfo(&aFSSpec,&dummyFInfo); + + if (nErr == fnfErr) // File Not Found, das ist was wir wollen ... + { + aRet = DirEntry( ret_val ); + break; + } + else if( nErr != noErr ) + { + DBG_ASSERT( nErr == noErr, "cannot generate TempName" ) + // keine Chance mehr, etwas zu finden + break; + } +#elif defined(PM2) +#ifdef POWERPC + // !!!!! DosQueryPathInfo liefert dezeit (Beta2) immer OK !!!!! + APIRET nRet; + HFILE hFile = 0; + PM_ULONG lAction = 0; + nRet = DosOpen( (PSZ)ret_val, &hFile, &lAction, 0, + FILE_NORMAL, FILE_OPEN, + OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, 0L ); + if ( !nRet ) + DosClose( hFile ); + else + { + aRet = DirEntry( ret_val ); + break; + } +#else + APIRET nRet; + ULONG nCount = 1; + HDIR hDirHandle = HDIR_SYSTEM; + FILEFINDBUF3 aDirEnt; + nRet = DosFindFirst( (PSZ) aRedirected.GetBuffer(), + &hDirHandle, 23, (PVOID) &aDirEnt, + sizeof( FILEFINDBUF3 ), + &nCount, FIL_STANDARD ); + if( nRet == ERROR_FILE_NOT_FOUND + || nRet == ERROR_NO_MORE_FILES ) + { + aRet = DirEntry( String( ret_val ) ); + break; + } + else if( nRet != NO_ERROR ) + { + DBG_ASSERT( nRet == NO_ERROR, "cannot generate TempName" ) + // keine Chance mehr, etwas zu finden + break; + } +#endif +#elif defined UNX + if( access( ByteString(aRedirected, osl_getThreadTextEncoding()).GetBuffer(), F_OK ) ) + { + aRet = DirEntry( aRetVal ); + break; + } +#else + struct stat aStat; + if ( stat( ByteString(aRedirected, osl_getThreadTextEncoding()).GetBuffer(), &aStat ) ) + { + aRet = DirEntry( aRetVal ); + break; + } +#endif + } + } + } + + delete ret_val; + ret_val = 0; + } + + return aRet; +} + +/************************************************************************* +|* +|* DirEntry::operator[]() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 03.03.92 +|* Letzte Aenderung MI 03.03.92 +|* +*************************************************************************/ + +const DirEntry &DirEntry::operator[]( USHORT nParentLevel ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + //TPF: maybe to be implemented (FastFSys) + + const DirEntry *pRes = this; + while ( pRes && nParentLevel-- ) + pRes = pRes->pParent; + + return *pRes; +} + +/************************************************************************* +|* +|* DirEntry::ImpParseUnixName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 26.05.93 +|* +*************************************************************************/ + +FSysError DirEntry::ImpParseUnixName( const ByteString& rPfad, FSysPathStyle eStyle ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // die einzelnen Namen auf einen Stack packen + DirEntryStack aStack; + ByteString aPfad( rPfad ); + do + { + // den Namen vor dem ersten "/" abspalten, + // falls '/' am Anfang, ist der Name '/', + // der Rest immer ohne die fuehrenden '/'. + // den ersten '/' suchen + USHORT nPos; + for ( nPos = 0; + nPos < aPfad.Len() && aPfad.GetChar(nPos) != '/'; + nPos++ ) + /* do nothing */; + + // ist der Name die Root des aktuellen Drives? + if ( nPos == 0 && aPfad.Len() > 0 && ( aPfad.GetChar(0) == '/' ) ) + { + // Root-Directory des aktuellen Drives + aStack.Push( new DirEntry( FSYS_FLAG_ABSROOT ) ); + } + else + { + // den Namen ohne Trenner abspalten + aName = aPfad.Copy( 0, nPos ); + + // stellt der Name die aktuelle Directory dar? + if ( aName == "." ) + /* do nothing */; + +#ifdef UNX + // stellt der Name das User-Dir dar? + else if ( aName == "~" ) + { + DirEntry aHome( String( (const char *) getenv( "HOME" ), osl_getThreadTextEncoding()) ); + for ( USHORT n = aHome.Level(); n; --n ) + aStack.Push( new DirEntry( aHome[ (USHORT) n-1 ] ) ); + } +#endif + + // stellt der Name die Parent-Directory dar? + else if ( aName == ".." ) + { + // ist nichts, ein Parent oder eine relative Root + // auf dem Stack? + if ( ( aStack.Count() == 0 ) || + ( aStack.Top()->eFlag == FSYS_FLAG_PARENT ) ) + // fuehrende Parents kommen auf den Stack + aStack.Push( new DirEntry( ByteString(), FSYS_FLAG_PARENT, eStyle ) ); + + // ist es eine absolute Root + else if ( aStack.Top()->eFlag == FSYS_FLAG_ABSROOT ) { + // die hat keine Parent-Directory + return FSYS_ERR_NOTEXISTS; + } + else + // sonst hebt der Parent den TOS auf + delete aStack.Pop(); + } + else + { + DirEntry *pNew = NULL; + // normalen Entries kommen auf den Stack + pNew = new DirEntry( aName, FSYS_FLAG_NORMAL, eStyle ); + if ( !pNew->IsValid() ) + { + aName = rPfad; + ErrCode eErr = pNew->GetError(); + delete pNew; + return eErr; + } + aStack.Push( pNew ); + } + } + + // den Restpfad bestimmen + aPfad.Erase( 0, nPos + 1 ); + while ( aPfad.Len() && ( aPfad.GetChar(0) == '/' ) ) + aPfad.Erase( 0, 1 ); + } + while ( aPfad.Len() ); + + // Haupt-Entry (selbst) zuweisen + if ( aStack.Count() == 0 ) + { + eFlag = FSYS_FLAG_CURRENT; + aName.Erase(); + } + else + { + eFlag = aStack.Top()->eFlag; + aName = aStack.Top()->aName; + delete aStack.Pop(); + } + + // die Parent-Entries vom Stack holen + DirEntry** pTemp = &pParent; + while ( aStack.Count() ) + { + *pTemp = aStack.Pop(); + pTemp = &( (*pTemp)->pParent ); + } + + return FSYS_ERR_OK; +} + +/************************************************************************* +|* +|* DirEntry::ImpParseMacName() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 14.10.91 +|* Letzte Aenderung MI 26.05.93 +|* +*************************************************************************/ + +FSysError DirEntry::ImpParseMacName( const ByteString& rPfad ) +{ +#if 0 + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntryStack aStack; + ByteString aPfad( rPfad ); + + //If the Path starts with an ABSROOT ( Volume ) it has to be + //pushed. So the Tail can be easier evaluated + if ( ( aPfad.Search( ':' ) != STRING_NOTFOUND ) && ( aPfad.GetChar(0) != ':' ) ) { + aStack.Push( new DirEntry( aPfad.Cut( 0, aPfad.Search( ':' ) ), + FSYS_FLAG_ABSROOT, FSYS_STYLE_MAC ) ); + aPfad.Erase( 0, 1 ); + } + + //Purge Current-Directory + if ( aPfad(0) == ':' ) + aPfad.Erase( 0, 1 ); + + //Evaluate the Tail + while ( aPfad.Len() ) { + + if ( aPfad.GetChar(0) == ':' ) { + //PARENT detected + if ( aStack.Count() && (aStack.Top()->eFlag == FSYS_FLAG_ABSROOT) ) { + //an ABSROOT couldn't have a PARENT + return FSYS_ERR_NOTEXISTS; + } + else { + //Nothing or a Parent at the top? + if ( ( aStack.Count() == 0 ) || + ( aStack.Top()->eFlag == FSYS_FLAG_PARENT ) ) { + //put leading Parents on the Top + aStack.Push( new DirEntry( FSYS_FLAG_PARENT ) ); + aPfad.Erase( 0, 1 ); + } + else { + delete aStack.Pop(); + aPfad.Erase( 0, 1 ); + } + } + } + else + { + // Normal entry detected + USHORT nSepPos = aPfad.Search( ':' ); + if ( STRING_NOTFOUND == nSepPos ) + nSepPos = USHRT_MAX; + DirEntry *pNew = new DirEntry( aPfad.Cut( 0, nSepPos ), + FSYS_FLAG_NORMAL, FSYS_STYLE_MAC ); + if ( !pNew->IsValid() ) + { + aName = rPfad; + ErrCode eErr = pNew->GetError(); + delete pNew; + return eErr; + } + aStack.Push( pNew ); + if ( STRING_NOTFOUND == nSepPos ) + aPfad.Erase(); + else + aPfad.Erase( 0, 1 ); + } + } + + //assign *this + if ( aStack.Count() == 0 ) { + eFlag = FSYS_FLAG_CURRENT; + aName.Erase(); + } + else { + eFlag = aStack.Top()->eFlag; + aName = aStack.Top()->aName; + delete aStack.Pop(); + } + //assign the Parent-Entries + DirEntry** pTemp = &pParent; + while ( aStack.Count() ) { + *pTemp = aStack.Pop(); + pTemp = &( (*pTemp)->pParent ); + } +#endif + return FSYS_ERR_OK; +} + +/************************************************************************* +|* +|* DirEntry::MakeShortName() +|* +|* Beschreibung +|* Ersterstellung TLX +|* Letzte Aenderung PB 21.08.97 (in CreateEntry_Impl()) +|* +*************************************************************************/ + +ErrCode CreateEntry_Impl( const DirEntry &rPath, DirEntryKind eKind ) +{ + // versuchen, anzulegen (ausser bei FSYS_KIND_ALL) + ErrCode eErr = ERRCODE_NONE; + if ( FSYS_KIND_FILE == eKind ) + { + SvFileStream aStream( rPath.GetFull(), STREAM_STD_WRITE ); + aStream.WriteLine( "" ); + eErr = aStream.GetError(); + } + else if ( FSYS_KIND_ALL != eKind ) + eErr = rPath.MakeDir() ? ERRCODE_NONE : ERRCODE_IO_UNKNOWN; + + // erfolgreich? + if ( !rPath.Exists() ) + eErr = ERRCODE_IO_UNKNOWN; // Doch was schiefgegangen ? + + // ggf. wieder l"oschen + if ( FSYS_KIND_NONE == eKind ) + rPath.Kill(); + + // Fehlercode zur?ckliefern + return eErr; +} + +BOOL IsValidEntry_Impl( const DirEntry &rPath, + const String &rLongName, + DirEntryKind eKind, + BOOL bIsShortened, + BOOL bUseDelim ) +{ + // Parameter-Pr"uefung + DBG_ASSERT( eKind == FSYS_KIND_NONE || eKind == FSYS_KIND_ALL || + eKind == FSYS_KIND_FILE || eKind == FSYS_KIND_DIR, + "invalid entry-kind" ); + + // Alle von MSDOS erreichbaren FSYS_STYLES muessen den + // MSDOS Filenamenanforderungen genuegen. Sonst wird probiert, + // ob sich eine Datei des gewuenschten Names anlegen laesst. + FSysPathStyle eStyle = DirEntry::GetPathStyle( rPath.GetDevice().GetName() ); + DirEntry aPath(rPath); + DirEntry aName(rLongName, eStyle); + if ( !aName.IsValid() || aName.Level() != 1 ) + return FALSE; + aPath += aName; + if ( 1 == aPath.Level() ) + return FALSE; + if ( eStyle == FSYS_STYLE_FAT || eStyle == FSYS_STYLE_NWFS || + eStyle == FSYS_STYLE_UNKNOWN ) + { + DirEntry aDosEntry( rLongName, FSYS_STYLE_FAT ); + if ( !aDosEntry.IsValid() ) + return FALSE; + } + + // Pfad-Trenner sind nicht erlaubt (bei ungek"urzten auch nicht FSYS_SHORTNAME_DELIMITER) + char cDelim = bUseDelim == 2 ? FSYS_SHORTNAME_DELIMITER : char(0); + if ( rLongName.Search( DirEntry::GetAccessDelimiter() ) != STRING_NOTFOUND || + !bIsShortened && rLongName.Search(cDelim) != STRING_NOTFOUND ) + return FALSE; + + // MI: Abfrage nach 'CON:' etc. wird jetzt in Exists() mitgemacht + if ( aPath.Exists() ) + return FALSE; + + return (ERRCODE_NONE == CreateEntry_Impl( aPath, eKind )); +} + +//------------------------------------------------------------------------- + +#define MAX_EXT_FAT 3 +#define MAX_LEN_FAT 8 +#define INVALID_CHARS_FAT "\\/\"':|^<>[]?* " + +#define MAX_EXT_MAC 16 // nur wegen sinnvoller Namensk"rzung +#define MAX_LEN_MAC 31 +#define INVALID_CHARS_MAC "\":" + +#define MAX_EXT_MAX 250 +#define MAX_LEN_MAX 255 +#define INVALID_CHARS_DEF "\\/\"':|^<>?*" + +BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind, + BOOL bUseDelim, FSysPathStyle eStyle ) +{ + String aLongName(rLongName); + + // Alle '#' aus den Dateinamen entfernen, weil das INetURLObject + // damit Probleme hat. Siehe auch #51246# + aLongName.EraseAllChars( '#' ); + ByteString bLongName(aLongName, osl_getThreadTextEncoding()); + + // Auf Novell-Servern (wegen der rottigen Clients) nur 7bit ASCII + + // HRO: #69627# Weg mit dem Scheiss. Wenn es Client gibt, die so einen + // BUG haben, dann muss halt der Client ersetzt werden, aber doch nicht das + // Office kastrieren !!! + +#if 0 + if ( FSYS_STYLE_NWFS == GetPathStyle( ImpGetTopPtr()->GetName() ) ) + { + for ( USHORT n = aLongName.Len(); n; --n ) + { + short nChar = aLongName(n-1); + if ( nChar < 32 || nChar >= 127 ) + aLongName.Erase( n-1, 1 ); + } + } +#endif + + // bei FSYS_KIND_ALL den alten Namen merken und abh"angen (rename) + ByteString aOldName; + if ( FSYS_KIND_ALL == eKind ) + { + aOldName = ByteString(CutName(), osl_getThreadTextEncoding()); + aOldName = CMP_LOWER(aOldName); + } + + // ist der Langname direkt verwendbar? + if ( IsValidEntry_Impl( *this, aLongName, eKind, FALSE, bUseDelim ) ) + { + operator+=( DirEntry(aLongName) ); + return TRUE; + } + + // max L"angen feststellen + USHORT nMaxExt, nMaxLen; + if ( FSYS_STYLE_DETECT == eStyle ) + eStyle = DirEntry::GetPathStyle( GetDevice().GetName() ); + ByteString aInvalidChars; + switch ( eStyle ) + { + case FSYS_STYLE_FAT: + nMaxExt = MAX_EXT_FAT; + nMaxLen = MAX_LEN_FAT; + aInvalidChars = INVALID_CHARS_FAT; + break; + + case FSYS_STYLE_MAC: + nMaxExt = MAX_EXT_MAC; + nMaxLen = MAX_LEN_MAC; + aInvalidChars = INVALID_CHARS_MAC; + break; + + default: + nMaxExt = MAX_EXT_MAX; + nMaxLen = MAX_LEN_MAX; + aInvalidChars = INVALID_CHARS_DEF; + } + + // Extension abschneiden und kuerzen + ByteString aExt; + ByteString aFName = bLongName; +#if defined(MAC) + if ( TRUE ) +#else + if ( FSYS_STYLE_MAC != eStyle ) +#endif + { + DirEntry aUnparsed; + aUnparsed.aName = bLongName; + aExt = ByteString(aUnparsed.CutExtension(), osl_getThreadTextEncoding()); + aFName = aUnparsed.aName; + if ( aExt.Len() > nMaxExt ) + { + char c = aExt.GetChar( aExt.Len() - 1 ); + aExt.Erase(nMaxExt-1); + aExt += c; + } + } + + if ( FSYS_STYLE_FAT != eStyle ) + { + // ausser auf einem FAT-System geh"ort die Extension zur + // Maxl"ange. Muss also vorher mit dem Punkt abgezogen werden. + nMaxLen -= ( aExt.Len() + 1 ); + } + + // Name k"urzen + ByteString aSName; + for ( const char *pc = aFName.GetBuffer(); aSName.Len() < nMaxLen && *pc; ++pc ) + { + if ( STRING_NOTFOUND == aInvalidChars.Search( *pc ) && + (unsigned char) *pc >= (unsigned char) 32 && + ( !aSName.Len() || *pc != ' ' || aSName.GetChar(aSName.Len()-1) != ' ' ) ) + aSName += *pc; + } + aSName.EraseTrailingChars(); + + // HRO: #74246# Also cut leading spaces + aSName.EraseLeadingChars(); + + if ( !aSName.Len() ) + aSName = "noname"; + + // kommt dabei der alte Name raus? + ByteString aNewName = aSName; + if ( aExt.Len() ) + ( aNewName += '.' ) += aExt; + operator+=( DirEntry(String(aNewName, osl_getThreadTextEncoding())) ); + if ( FSYS_KIND_ALL == eKind && CMP_LOWER(aName) == aOldName ) + if ( FSYS_KIND_ALL == eKind && CMP_LOWER(ByteString(GetName(), osl_getThreadTextEncoding())) == aOldName ) + return TRUE; + + // kann der gek"urzte Name direkt verwendet werden? + if ( !Exists() && (ERRCODE_NONE == CreateEntry_Impl( *this, eKind )) ) + return TRUE; + + // darf '?##' verwendet werden, um eindeutigen Name zu erzeugen? + if ( bUseDelim ) + { + // eindeutigen Namen per '?##' erzeugen + aSName.Erase( nMaxLen-3 ); + if ( bUseDelim != 2 ) + aSName += FSYS_SHORTNAME_DELIMITER; + for ( int n = 1; n < 99; ++n ) + { + // Name zusammensetzen + ByteString aTmpStr( aSName ); + aTmpStr += n; + if ( aExt.Len() ) + ( aTmpStr += '.' ) += aExt; + + // noch nicht vorhanden? + SetName( String(aTmpStr, osl_getThreadTextEncoding()) ); + + if ( !Exists() ) + { + // Fehler setzen !!! + nError = CreateEntry_Impl( *this, eKind ); + return (ERRCODE_NONE == nError); + } + } + } + + // keine ## mehr frei / ?## soll nicht verwendet werden + nError = ERRCODE_IO_ALREADYEXISTS; + return FALSE; +} + +/************************************************************************* +|* +|* DirEntry::CreatePath() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +BOOL DirEntry::MakeDir( BOOL bSloppy ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + // Schnellpruefung, ob vorhanden + if ( FileStat( *this ).IsKind( FSYS_KIND_DIR ) ) + return TRUE; + if ( bSloppy && pParent ) + if ( FileStat( *pParent ).IsKind( FSYS_KIND_DIR ) ) + return TRUE; + + const DirEntry *pNewDir = bSloppy ? pParent : this; + if ( pNewDir ) + { + // den Path zum Dir erzeugen + if ( pNewDir->pParent && !pNewDir->pParent->MakeDir(FALSE) ) + return FALSE; + + // das Dir selbst erzeugen + if ( pNewDir->eFlag == FSYS_FLAG_ABSROOT || + pNewDir->eFlag == FSYS_FLAG_ABSROOT || + pNewDir->eFlag == FSYS_FLAG_VOLUME ) + return TRUE; + else + { + //? nError = ??? + if ( FileStat( *pNewDir ).IsKind( FSYS_KIND_DIR ) ) + return TRUE; + else + { + FSysFailOnErrorImpl(); + String aDirName(pNewDir->GetFull()); +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect( aDirName ); +#endif + ByteString bDirName( aDirName, osl_getThreadTextEncoding() ); + bDirName = GUI2FSYS( bDirName ); + +#ifdef WIN32 + SetLastError(0); +#endif + BOOL bResult = (0 == _mkdir( (char*) bDirName.GetBuffer() )); + if ( !bResult ) + { + // Wer hat diese Methode const gemacht ? +#ifdef WIN32 + ((DirEntry *)this)->SetError( Sys2SolarError_Impl( GetLastError() ) ); +#else + ((DirEntry *)this)->SetError( Sys2SolarError_Impl( errno ) ); +#endif + } + + return bResult; + } + } + } + return TRUE; +} + +/************************************************************************* +|* +|* DirEntry::CopyTo() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 07.08.96 +|* +*************************************************************************/ + +FSysError DirEntry::CopyTo( const DirEntry& rDest, FSysAction nActions ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( FSYS_ACTION_COPYFILE != (nActions & FSYS_ACTION_COPYFILE) ) +#ifdef UNX + { + // Hardlink anlegen + HACK(redirection missing) + ByteString aThis(GUI2FSYS(GetFull()), osl_getThreadTextEncoding()); + ByteString aDest(GUI2FSYS(rDest.GetFull()), osl_getThreadTextEncoding()); + link( aThis.GetBuffer(), aDest.GetBuffer() ); + return Sys2SolarError_Impl( errno ); + } +#else + return FSYS_ERR_NOTSUPPORTED; +#endif + + return FileCopier( *this, rDest ).Execute(nActions); +} + +/************************************************************************* +|* +|* DirEntry::MoveTo() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung HRO 24.03.99 +|* +*************************************************************************/ + +#if defined(WNT) || defined(DOS) || defined(WIN) || defined(UNX) + +FSysError DirEntry::MoveTo( const DirEntry& rNewName ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + +/* + FileStat aSourceStat(*this); + if ( !aSourceStat.IsKind(FSYS_KIND_FILE) ) + return FSYS_ERR_NOTAFILE; +*/ + + DirEntry aDest(rNewName); + FileStat aDestStat(rNewName); + if ( aDestStat.IsKind(FSYS_KIND_DIR ) ) + { + aDest += String(aName, osl_getThreadTextEncoding()); + } + if ( aDest.Exists() ) + { + return FSYS_ERR_ALREADYEXISTS; + } + +#ifdef WIN + if ( FileStat(*this).IsKind(FSYS_KIND_DIR) && aDest.GetPath() != GetPath() ) + { + return FSYS_ERR_NOTSUPPORTED; + } +#endif + + FSysFailOnErrorImpl(); + String aFrom( GetFull() ); + +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect(aFrom); +#endif + + String aTo( aDest.GetFull() ); + +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect(aTo); +#endif + + ByteString bFrom(aFrom, osl_getThreadTextEncoding()); + ByteString bTo(aTo, osl_getThreadTextEncoding()); + bFrom = GUI2FSYS(bFrom); + bTo = GUI2FSYS(bTo); + +#ifdef WNT + // MoveTo nun atomar + SetLastError(0); + + DirEntry aFromDevice(String(bFrom, osl_getThreadTextEncoding())); + DirEntry aToDevice(String(bTo,osl_getThreadTextEncoding())); + aFromDevice.ToAbs(); + aToDevice.ToAbs(); + aFromDevice=aFromDevice.GetDevice(); + aToDevice=aToDevice.GetDevice(); + + //Quelle und Ziel auf gleichem device? + if (aFromDevice==aToDevice) + { + // ja, also intra-device-move mit MoveFile + MoveFile( bFrom.GetBuffer(), bTo.GetBuffer() ); + // MoveFile ist buggy bei cross-device operationen. + // Der R?ckgabewert ist auch dann TRUE, wenn nur ein Teil der Operation geklappt hat. + // Zudem zeigt MoveFile unterschiedliches Verhalten bei unterschiedlichen NT-Versionen. + return Sys2SolarError_Impl( GetLastError() ); + } + else + { + //nein, also inter-device-move mit copy/delete + FSysError nCopyError = CopyTo(rNewName, FSYS_ACTION_COPYFILE); + + DirEntry aKill(String(bTo, osl_getThreadTextEncoding())); + FileStat aKillStat(String(bTo, osl_getThreadTextEncoding())); + if ( aKillStat.IsKind(FSYS_KIND_DIR ) ) + { + aKill += String(aName, osl_getThreadTextEncoding()); + } + + if (nCopyError==FSYS_ERR_OK) + { + if (Kill()==FSYS_ERR_OK) + { + return FSYS_ERR_OK; + } + else + { + aKill.Kill(); + return FSYS_ERR_ACCESSDENIED; + } + } + else + { + aKill.Kill(); + return nCopyError; + } + } +#else + // #68639# + // on some nfs connections rename with from == to + // leads to destruction of file + if ( ( aFrom != aTo ) && ( 0 != rename( bFrom.GetBuffer(), bTo.GetBuffer() ) ) ) +#ifndef UNX +#ifdef WIN + { // einfaches umbenennen ist fehlgeschlagen, kopieren versuchen + FILE *fpIN = fopen(aFrom.GetBuffer(), "rb"); + if (!fpIN) return Sys2SolarError_Impl(ENOENT); // Quelle kann nicht zum Lesen geoeffnet werden + FILE *fpOUT = fopen(aTo, "wb"); + if (!fpOUT) + { + fclose(fpIN); + return Sys2SolarError_Impl(EACCES); // Ziel kann nicht zum Schreiben geoeffnet werden + } + + char pBuf[16384]; + int nRead, nWrite, nError = 0; + while((nRead = fread(pBuf, 1, 16384, fpIN)) && (!nError)) + { + nWrite = fwrite(pBuf, 1, nRead, fpOUT); + if (nWrite != nRead) nError = ENOSPC; + } + fclose( fpIN ); + fclose( fpOUT ); + return Sys2SolarError_Impl(nError); + } +#else + return Sys2SolarError_Impl( GetLastError() ); +#endif +#else + { + if( errno == EXDEV ) +// cross device geht latuernich nicht mit rename + { + FILE *fpIN = fopen( bFrom.GetBuffer(), "r" ); + FILE *fpOUT = fopen( bTo.GetBuffer(), "w" ); + if( fpIN && fpOUT ) + { + char pBuf[ 16384 ]; + int nBytes, nWritten, nError = 0; + errno = 0; + while( ( nBytes = fread( pBuf, 1, sizeof(pBuf), fpIN ) ) && ! nError ) + { + nWritten = fwrite( pBuf, 1, nBytes, fpOUT ); + // Fehler im fwrite ? + if( nWritten < nBytes ) + { + nError = errno; + break; + } + } + fclose( fpIN ); + fclose( fpOUT ); + if ( nError ) + { + unlink( bTo.GetBuffer() ); + return Sys2SolarError_Impl( nError ); + } + else + { + unlink( bFrom.GetBuffer() ); + } + } + else + { + return Sys2SolarError_Impl( EXDEV ); + } + } + else + { + return Sys2SolarError_Impl( errno ); + } + } +#endif +#endif + return ERRCODE_NONE; +} + +#endif + +/************************************************************************* +|* +|* DirEntry::Kill() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 07.08.96 +|* +*************************************************************************/ + +FSysError DirEntry::Kill( FSysAction nActions ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + FSysError eError = FSYS_ERR_OK; + FSysFailOnErrorImpl(); + + // Name als doppelt 0-terminierter String + String aTmpName( GetFull() ); +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect( aTmpName ); +#endif + ByteString bTmpName( aTmpName, osl_getThreadTextEncoding()); + bTmpName = GUI2FSYS(bTmpName); + + char *pName = new char[bTmpName.Len()+2]; + strcpy( pName, bTmpName.GetBuffer() ); + pName[bTmpName.Len()+1] = (char) 0; + + //read-only files sollen auch geloescht werden koennen + BOOL isReadOnly = FileStat::GetReadOnlyFlag(*this); + if (isReadOnly) + { + FileStat::SetReadOnlyFlag(*this, FALSE); + } + + // directory? + if ( FileStat( *this ).IsKind(FSYS_KIND_DIR) ) + { + // Inhalte recursiv loeschen? + if ( FSYS_ACTION_RECURSIVE == (nActions & FSYS_ACTION_RECURSIVE) ) + { + Dir aDir( *this, FSYS_KIND_DIR|FSYS_KIND_FILE ); + for ( USHORT n = 0; eError == FSYS_ERR_OK && n < aDir.Count(); ++n ) + { + const DirEntry &rSubDir = aDir[n]; + DirEntryFlag eFlag = rSubDir.GetFlag(); + if ( eFlag != FSYS_FLAG_CURRENT && eFlag != FSYS_FLAG_PARENT ) + eError = rSubDir.Kill(nActions); + } + } + + // das Dir selbst loeschen +#ifdef WIN32 + SetLastError(0); +#endif + if ( eError == FSYS_ERR_OK && 0 != _rmdir( (char*) pName ) ) + // + { + // falls L"oschen nicht ging, CWD umsetzen +#ifdef WIN32 + eError = Sys2SolarError_Impl( GetLastError() ); +#else + eError = Sys2SolarError_Impl( errno ); +#endif + if ( eError ) + { + GetPath().SetCWD(); +#ifdef WIN32 + SetLastError(0); +#endif + if (_rmdir( (char*) pName) != 0) + { +#ifdef WIN32 + eError = Sys2SolarError_Impl( GetLastError() ); +#else + eError = Sys2SolarError_Impl( errno ); +#endif + } + else + { + eError = FSYS_ERR_OK; + } + } + } + } + else + { + if ( FSYS_ACTION_USERECYCLEBIN == (nActions & FSYS_ACTION_USERECYCLEBIN) ) + { +#ifdef OS2 + eError = ApiRet2ToSolarError_Impl( DosDelete( (char*) pName ) ); +#else +#ifdef WNT + SHFILEOPSTRUCT aOp; + aOp.hwnd = 0; + aOp.wFunc = FO_DELETE; + aOp.pFrom = pName; + aOp.pTo = 0; + aOp.fFlags = FOF_ALLOWUNDO|FOF_SILENT|FOF_NOCONFIRMATION; + aOp.hNameMappings = 0; + aOp.lpszProgressTitle = 0; + eError = Sys2SolarError_Impl( SHFileOperation( &aOp ) ); +#else + eError = ERRCODE_IO_NOTSUPPORTED; +#endif +#endif + } + else + { +#ifdef OS2 + eError = ApiRet2ToSolarError_Impl( DosForceDelete( (PSZ) pName ) ); +#else +#ifdef WIN32 + SetLastError(0); +#endif + if ( 0 != _unlink( (char*) pName ) ) + { +#ifdef WIN32 + eError = Sys2SolarError_Impl( GetLastError() ); +#else + eError = Sys2SolarError_Impl( errno ); +#endif + } + else + { + eError = ERRCODE_NONE; + } +#endif + } + } + + //falls Fehler, originales read-only flag wieder herstellen + if ( isReadOnly && (eError!=ERRCODE_NONE) ) + { + FileStat::SetReadOnlyFlag(*this, isReadOnly); + } + + delete pName; + return eError; +} + +/************************************************************************* +|* +|* DirEntry::Contains() +|* +|* Beschreibung ob rSubEntry direkt oder indirect in *this liegt +|* Ersterstellung MI 20.03.97 +|* Letzte Aenderung MI 20.03.97 +|* +*************************************************************************/ + +BOOL DirEntry::Contains( const DirEntry &rSubEntry ) const +{ + DBG_ASSERT( IsAbs() && rSubEntry.IsAbs(), "must be absolute entries" ); + + USHORT nThisLevel = Level(); + USHORT nSubLevel = rSubEntry.Level(); + if ( nThisLevel < nSubLevel ) + { + for ( ; nThisLevel; --nThisLevel, --nSubLevel ) + if ( (*this)[nThisLevel-1] != rSubEntry[nSubLevel-1] ) + return FALSE; + return TRUE; + } + return FALSE; +} + +/************************************************************************* +|* +|* DirEntry::Level() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 03.03.92 +|* Letzte Aenderung MI 03.03.92 +|* +*************************************************************************/ + +USHORT DirEntry::Level() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + USHORT nLevel = 0; + const DirEntry *pRes = this; + while ( pRes ) + { + pRes = pRes->pParent; + nLevel++; + } + + return nLevel; +} + +/************************************************************************* +|* +|* DirEntry::ConvertNameToSystem() +|* +|* Beschreibung +|* Ersterstellung DV 29.03.96 +|* Letzte Aenderung DV 29.03.96 +|* +*************************************************************************/ + +String DirEntry::ConvertNameToSystem( const String &rName ) +{ +#ifdef MAC + return ImpConvertNameToSystem( rName ); +#else + return rName; +#endif +} + +/************************************************************************* +|* +|* DirEntry::ConvertSystemToName() +|* +|* Beschreibung +|* Ersterstellung DV 29.03.96 +|* Letzte Aenderung DV 29.03.96 +|* +*************************************************************************/ + +String DirEntry::ConvertSystemToName( const String &rName ) +{ +#ifdef MAC + return ImpConvertSystemToName( rName ); +#else + return rName; +#endif +} + +/************************************************************************* +|* +|* DirEntry::IsValid() +|* +|* Beschreibung +|* Ersterstellung MI 18.09.93 +|* Letzte Aenderung TPF 18.09.98 +|* +*************************************************************************/ + +BOOL DirEntry::IsValid() const +{ + return (nError == FSYS_ERR_OK); +} + +/************************************************************************* +|* +|* DirEntry::IsRFSAvailable() +|* +|* Beschreibung +|* Ersterstellung TPF 21.10.98 +|* Letzte Aenderung TPF 21.10.98 +|* +*************************************************************************/ + +BOOL DirEntry::IsRFSAvailable() +{ + return FALSE; +} + +/************************************************************************* +|* +|* IsLongNameOnFAT() +|* +|* Beschreibung ?berpr?ft , ob das DirEntry einen langen +|* Filenamen auf einer FAT-Partition enth?lt (EAs). +|* (eigentlich nur f?r OS2 interessant) +|* Ersterstellung TPF 02.10.98 +|* Letzte Aenderung TPF 01.03.1999 +|* +*************************************************************************/ + +BOOL DirEntry::IsLongNameOnFAT() const +{ + // FAT-System? + DirEntry aTempDirEntry(*this); + aTempDirEntry.ToAbs(); + if (DirEntry::GetPathStyle(aTempDirEntry.GetDevice().GetName().GetChar(0)) != FSYS_STYLE_FAT) + { + return FALSE; // nein, also false + } + + // DirEntry-Kette auf lange Dateinamen pr?fen + for( int iLevel = this->Level(); iLevel > 0; iLevel-- ) + { + const DirEntry& rEntry = (const DirEntry&) (*this)[iLevel-1]; + String aBase( rEntry.GetBase() ); + String aExtension( rEntry.GetExtension() ); + + if (aBase.Len()>8) // Name > 8? + { + return TRUE; + } + + if (aExtension.Len()>3) // Extension > 3? + { + return TRUE; + } + } + return FALSE; +} + +//======================================================================== + +#if defined(DBG_UTIL) + +void FSysTest() +{ +} + +#endif + diff --git a/tools/source/fsys/filecopy.cxx b/tools/source/fsys/filecopy.cxx new file mode 100644 index 000000000000..6be1822f8991 --- /dev/null +++ b/tools/source/fsys/filecopy.cxx @@ -0,0 +1,578 @@ +/************************************************************************* + * + * $RCSfile: filecopy.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#if defined(WIN) || defined(WNT) +#ifndef _SVWIN_H +#include <io.h> +#include <svwin.h> +#endif + +#elif defined(PM2) || defined(DOS) +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <share.h> +#include <io.h> + +#elif defined UNX +#include <fcntl.h> +#include <unistd.h> +#include <sys/stat.h> + +#elif defined MAC +#include <mac_start.h> +#include <fcntl.h> +#include <mac_end.h> +#endif + +#include <ctype.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> + +#ifndef PM2 +#include <stdio.h> +#endif + +#ifndef _COMDEP_HXX +#include "comdep.hxx" +#endif + +#ifndef _FSYS_HXX +#include "fsys.hxx" +#endif + +#ifndef _STREAM_HXX +#ifdef UNX +#define private public +#endif +#include "stream.hxx" +#endif + +EA_Copier* EA_Copier::_pCopier = NULL; + +//======================================================================== + +EA_Copier::~EA_Copier() +{ +} + +//------------------------------------------------------------------------ +void EA_Copier::Register( EA_Copier* pCopier ) +{ + _pCopier = pCopier; +} + +//------------------------------------------------------------------------ + +EA_Copier* EA_Copier::Get() +{ + return _pCopier; +} + +/************************************************************************* +|* +|* FileCopier::FileCopier() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.04.94 +|* Letzte Aenderung MI 13.04.94 +|* +*************************************************************************/ + +FileCopier::FileCopier() : + + nBlockSize ( 4096 ), + nBytesTotal ( 0 ), + nBytesCopied( 0 ), + pImp ( new FileCopier_Impl ) + +{ +} + +// ----------------------------------------------------------------------- + +FileCopier::FileCopier( const DirEntry& rSource, const DirEntry& rTarget ) : + + aSource ( rSource ), + aTarget ( rTarget ), + nBlockSize ( 4096 ), + nBytesTotal ( 0 ), + nBytesCopied( 0 ), + pImp ( new FileCopier_Impl ) + +{ +} + +// ----------------------------------------------------------------------- + +FileCopier::FileCopier( const FileCopier& rCopier ) : + + aSource ( rCopier.aSource ), + aTarget ( rCopier.aTarget ), + nBlockSize ( 4096 ), + nBytesTotal ( 0 ), + nBytesCopied ( 0 ), + aProgressLink ( rCopier.aProgressLink ), + pImp ( new FileCopier_Impl ) + +{ +} + +/************************************************************************* +|* +|* FileCopier::~FileCopier() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.04.94 +|* Letzte Aenderung MI 13.04.94 +|* +*************************************************************************/ + +FileCopier::~FileCopier() +{ + delete pImp; +} + +/************************************************************************* +|* +|* FileCopier::operator =() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.04.94 +|* Letzte Aenderung MI 13.04.94 +|* +*************************************************************************/ + +FileCopier& FileCopier::operator = ( const FileCopier &rCopier ) +{ + aSource = rCopier.aSource; + aTarget = rCopier.aTarget; + nBytesTotal = rCopier.nBytesTotal; + nBytesCopied = rCopier.nBytesCopied; + nBytesCopied = rCopier.nBytesCopied; + nBlockSize = rCopier.nBlockSize; + aProgressLink = rCopier.aProgressLink; + *pImp = *(rCopier.pImp); + return *this; +} + +/************************************************************************* +|* +|* FileCopier::Progress() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.04.94 +|* Letzte Aenderung MI 13.04.94 +|* +*************************************************************************/ + +BOOL FileCopier::Progress() +{ + if ( !aProgressLink ) + return TRUE; + else + { + if ( aProgressLink.Call( this ) ) + return TRUE; + return ( 0 == Error( ERRCODE_ABORT, 0, 0 ) ); + } +} + +//--------------------------------------------------------------------------- + +ErrCode FileCopier::Error( ErrCode eErr, const DirEntry* pSource, const DirEntry* pTarget ) +{ + // kein Fehler oder kein ErrorHandler? + if ( !eErr || !pImp->aErrorLink ) + // => Error beibehalten + return eErr; + + // sonst gesetzten ErrorHandler fragen + pImp->pErrSource = pSource; + pImp->pErrTarget = pTarget; + pImp->eErr = eErr; + ErrCode eRet = (ErrCode) pImp->aErrorLink.Call( this ); + pImp->pErrSource = 0; + pImp->pErrTarget = 0; + return eRet; +} + +//--------------------------------------------------------------------------- + +const DirEntry* FileCopier::GetErrorSource() const +{ + return pImp->pErrSource; +} + +//--------------------------------------------------------------------------- + +const DirEntry* FileCopier::GetErrorTarget() const +{ + return pImp->pErrTarget; +} + +//--------------------------------------------------------------------------- + +ErrCode FileCopier::GetError() const +{ + return pImp->eErr; +} + +//--------------------------------------------------------------------------- + +void FileCopier::SetErrorHdl( const Link &rLink ) +{ + pImp->aErrorLink = rLink; +} + +//--------------------------------------------------------------------------- + +const Link& FileCopier::GetErrorHdl() const +{ + return pImp->aErrorLink ; +} + +/************************************************************************* +|* +|* FileCopier::Execute() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 13.04.94 +|* Letzte Aenderung PB 16.06.00 +|* +*************************************************************************/ + +#ifndef MAC + +#ifdef OS2 +BOOL createLongNameEA ( const PCSZ pszPath, ULONG ulAttributes, const String& aLongName ); +#endif + +FSysError FileCopier::DoCopy_Impl( const DirEntry &rSource, const DirEntry &rTarget, + BOOL bTop ) +{ + FSysError eRet = FSYS_ERR_OK; + ErrCode eWarn = FSYS_ERR_OK; + + // HPFS->FAT? + FSysPathStyle eSourceStyle = DirEntry::GetPathStyle( rSource.ImpGetTopPtr()->GetName() ); + FSysPathStyle eTargetStyle = DirEntry::GetPathStyle( rTarget.ImpGetTopPtr()->GetName() ); + BOOL bMakeShortNames = ( eSourceStyle == FSYS_STYLE_HPFS && eTargetStyle == FSYS_STYLE_FAT ); + + // Zieldateiname ggf. kuerzen + DirEntry aTarget; + if ( bMakeShortNames ) + { + aTarget = rTarget.GetPath(); + aTarget.MakeShortName( rTarget.GetName() ); + } + else + aTarget = rTarget; + + // kein Move wenn Namen gekuerzt werden muessten + if ( bMakeShortNames && FSYS_ACTION_MOVE == ( pImp->nActions & FSYS_ACTION_MOVE ) && aTarget != rTarget ) + return ERRCODE_IO_NAMETOOLONG; + + // source is directory? + FileStat aSourceFileStat( rSource ); + if ( aSourceFileStat.IsKind( FSYS_KIND_DIR ) ) + { +#ifdef OS2 + CHAR szSource[CCHMAXPATHCOMP]; + HOBJECT hSourceObject; + + strcpy(szSource, rSource.GetFull().GetStr()); + hSourceObject = WinQueryObject(szSource); + + if ( hSourceObject ) + { + PSZ pszSourceName; + PSZ pszTargetName; + CHAR szTarget[CCHMAXPATHCOMP]; + HOBJECT hTargetObject; + HOBJECT hReturn = NULLHANDLE; + + strcpy(szTarget, rTarget.GetFull().GetStr()); + pszTargetName = strrchr(szTarget, '\\'); + pszSourceName = strrchr(szSource, '\\'); + + hTargetObject = WinQueryObject(szTarget); + + if ( hTargetObject ) + WinDestroyObject(hTargetObject); + + if ( pszTargetName && pszSourceName ) + { + *pszTargetName = '\0'; + pszSourceName++; + pszTargetName++; + + if(strcmp(pszSourceName, pszTargetName) == 0) + { + hTargetObject = WinQueryObject(szTarget); + + if(pImp->nActions & FSYS_ACTION_MOVE) + { + hReturn = WinMoveObject(hSourceObject, hTargetObject, 0); + } + else + { + hReturn = WinCopyObject(hSourceObject, hTargetObject, 0); + } + if ( bMakeShortNames && aTarget.Exists() ) + aTarget.Kill(); + return hReturn ? FSYS_ERR_OK : FSYS_ERR_UNKNOWN; + } + } + } +#endif + // recursive copy + eRet = Error( aTarget.MakeDir() ? FSYS_ERR_OK : FSYS_ERR_UNKNOWN, 0, &aTarget ); + Dir aSourceDir( rSource, FSYS_KIND_DIR|FSYS_KIND_FILE ); + for ( USHORT n = 0; ERRCODE_TOERROR(eRet) == FSYS_ERR_OK && n < aSourceDir.Count(); ++n ) + { + const DirEntry &rSubSource = aSourceDir[n]; + DirEntryFlag eFlag = rSubSource.GetFlag(); + if ( eFlag != FSYS_FLAG_CURRENT && eFlag != FSYS_FLAG_PARENT ) + { + DirEntry aSubTarget( aTarget ); + aSubTarget += rSubSource.GetName(); + eRet = DoCopy_Impl( rSubSource, aSubTarget, FALSE ); + if ( eRet && !eWarn ) + eWarn = eRet; + } + } + } + else if ( aSourceFileStat.IsKind(FSYS_KIND_FILE) ) + { + if ( ( FSYS_ACTION_KEEP_EXISTING == ( pImp->nActions & FSYS_ACTION_KEEP_EXISTING ) ) && + aTarget.Exists() ) + { + // Do not overwrite existing file in target folder. + return ERRCODE_NONE; + } + + // copy file + nBytesCopied = 0; + nBytesTotal = FileStat( rSource ).GetSize(); + + String aFileName( GUI2FSYS( rSource.GetFull() ).GetBuffer() ); + SvFileStream aSource( aFileName, STREAM_READ|STREAM_NOCREATE|STREAM_SHARE_DENYNONE ); + + if ( !aSource.GetError() ) + { +#ifdef UNX + struct stat buf; + if ( fstat( aSource.GetFileHandle(), &buf ) == -1 ) + eRet = Error( FSYS_ERR_ACCESSDENIED, 0, &aTarget ); +#endif + SvFileStream aTargetStream( GUI2FSYS( aTarget.GetFull() ), + STREAM_WRITE | STREAM_TRUNC | STREAM_SHARE_DENYWRITE ); + if ( !aTargetStream.GetError() ) + { +#ifdef UNX + if ( fchmod( aTargetStream.GetFileHandle(), buf.st_mode ) == -1 ) + eRet = Error( FSYS_ERR_ACCESSDENIED, 0, &aTarget ); +#endif + size_t nAllocSize = 0, nSize = 0; + char *pBuf = 0; + while ( Progress() && nSize == nAllocSize && eRet == FSYS_ERR_OK ) + { + // adjust the block-size + if ( nBlockSize > nAllocSize ) + { + delete pBuf; + nAllocSize = nBlockSize; + pBuf = new char[nAllocSize]; + } + + // copy one block + nSize = aSource.Read( pBuf, nBlockSize ); + aTargetStream.Write( pBuf, nSize ); + if ( aTargetStream.GetError() ) + eRet = Error( aTargetStream.GetError(), 0, &aTarget ); + + // adjust counters + nBytesCopied += nSize; + if ( nBytesCopied > nBytesTotal ) + nBytesTotal = nBytesCopied; + } + delete pBuf; + } + else + eRet = Error( aTargetStream.GetError(), 0, &aTarget ); + + // ggf. EAs kopieren + if ( !eRet && EA_Copier::Get() && !EA_Copier::Get()->Copy( aSource, aTargetStream ) ) + eRet = FSYS_ERR_UNKNOWN | ERRCODE_WARNING_MASK; + + // unvollstaendiges File wieder loeschen + aTargetStream.Close(); + + if ( nBytesCopied != nBytesTotal ) + { + aTarget.Kill(); + } +#ifdef OS2 + else + { + // falls die Source-Target-Filenamen nicht gleich sind und der Target-Filename nicht + // 8.3 aber auf FAT ist, dann mu? das EA .longname korrekt gesetzt werden (TPF) + // (rSource.GetName()!=rTarget.GetName()) + + if ( rTarget.IsLongNameOnFAT() && Folder::IsAvailable() ) + { + createLongNameEA( (const char*)aTargetStream.GetFileName(), + FILE_NORMAL, rTarget.GetName() ); + } + } +#endif + } + else + eRet = Error( aSource.GetError(), &rSource, 0 ); + } + else if ( aSourceFileStat.IsKind(FSYS_KIND_NONE) ) + eRet = Error( ERRCODE_IO_NOTEXISTS, &rSource, 0 ); + else + eRet = Error( ERRCODE_IO_NOTSUPPORTED, &rSource, 0 ); + +#ifdef WNT + // Set LastWriteTime and Attributes of the target identical with the source + + if ( FSYS_ERR_OK == ERRCODE_TOERROR(eRet) ) + { + WIN32_FIND_DATA fdSource; + ByteString aFullSource(aSource.GetFull(), osl_getThreadTextEncoding()); + ByteString aFullTarget(aTarget.GetFull(), osl_getThreadTextEncoding()); + HANDLE hFind = FindFirstFile( aFullSource.GetBuffer() , &fdSource ); + if ( hFind != INVALID_HANDLE_VALUE ) + { + FindClose( hFind ); + + HANDLE hFile = CreateFile( aFullTarget.GetBuffer(), GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + + if ( hFile != INVALID_HANDLE_VALUE ) + { + SetFileTime( hFile, NULL, NULL, &fdSource.ftLastWriteTime ); + CloseHandle( hFile ); + } + + SetFileAttributes( aFullTarget.GetBuffer(), fdSource.dwFileAttributes ); + } + } +#endif + // bei Move ggf. das File/Dir loeschen + if ( FSYS_ERR_OK == ERRCODE_TOERROR(eRet) && ( pImp->nActions & FSYS_ACTION_MOVE ) ) + { + ErrCode eKillErr = Error( rSource.Kill() | ERRCODE_WARNING_MASK, &rSource, 0 ); + if ( eKillErr != ERRCODE_WARNING_MASK ) + { + if ( rSource.Exists() ) + // loeschen ging nicht => dann die Kopie wieder loeschen + aTarget.Kill( pImp->nActions ); + if ( !eWarn ) + eWarn = eKillErr; + } + } + + return !eRet ? eWarn : eRet; +} + +#endif + +// ----------------------------------------------------------------------- + +FSysError FileCopier::Execute( FSysAction nActions ) +{ + return ExecuteExact( nActions ); +} + +// ----------------------------------------------------------------------- + +FSysError FileCopier::ExecuteExact( FSysAction nActions, FSysExact eExact ) +{ + DirEntry aAbsSource = DirEntry( aSource); + DirEntry aAbsTarget = DirEntry( aTarget ); + pImp->nActions = nActions; + + // check if both pathes are accessible and source and target are different + if ( !aAbsTarget.ToAbs() || !aAbsSource.ToAbs() || aAbsTarget == aAbsSource ) + return FSYS_ERR_ACCESSDENIED; + + // check if copy would be endless recursive into itself + if ( FSYS_ACTION_RECURSIVE == ( nActions & FSYS_ACTION_RECURSIVE ) && + aAbsSource.Contains( aAbsTarget ) ) + return ERRCODE_IO_RECURSIVE; + + // target is directory? + if ( eExact == FSYS_NOTEXACT && + FileStat( aAbsTarget ).IsKind(FSYS_KIND_DIR) && FileStat( aAbsSource ).IsKind(FSYS_KIND_FILE) ) + // append name of source + aAbsTarget += aSource.GetName(); + + // recursive copy + return DoCopy_Impl( aAbsSource, aAbsTarget, TRUE ); +} + + diff --git a/tools/source/fsys/fstat.cxx b/tools/source/fsys/fstat.cxx new file mode 100644 index 000000000000..bbde14c83208 --- /dev/null +++ b/tools/source/fsys/fstat.cxx @@ -0,0 +1,516 @@ +/************************************************************************* + * + * $RCSfile: fstat.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#if defined( WIN) +#include <stdio.h> +#include <dos.h> +#endif + +#ifdef UNX +#include <errno.h> +#endif + +#include <limits.h> +#include <string.h> + +#include "comdep.hxx" +#include <fsys.hxx> + +/************************************************************************* +|* +|* FileStat::FileStat() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 11.06.91 +|* Letzte Aenderung MI 11.06.91 +|* +*************************************************************************/ + +FileStat::FileStat() +: // don't use Default-Ctors! + aDateCreated( ULONG(0) ), + aTimeCreated( ULONG(0) ), + aDateModified( ULONG(0) ), + aTimeModified( ULONG(0) ), + aDateAccessed( ULONG(0) ), + aTimeAccessed( ULONG(0) ) +{ + nSize = 0; + nKindFlags = FSYS_KIND_UNKNOWN; + nError = FSYS_ERR_OK; +} + +/************************************************************************* +|* +|* FileStat::FileStat() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 11.06.91 +|* Letzte Aenderung MI 11.06.91 +|* +*************************************************************************/ + +FileStat::FileStat( const DirEntry& rDirEntry, FSysAccess nAccess ) +: // don't use Default-Ctors! + aDateCreated( ULONG(0) ), + aTimeCreated( ULONG(0) ), + aDateModified( ULONG(0) ), + aTimeModified( ULONG(0) ), + aDateAccessed( ULONG(0) ), + aTimeAccessed( ULONG(0) ) +{ + BOOL bCached = FSYS_ACCESS_CACHED == (nAccess & FSYS_ACCESS_CACHED); + BOOL bFloppy = FSYS_ACCESS_FLOPPY == (nAccess & FSYS_ACCESS_FLOPPY); + +#ifdef FEAT_FSYS_DOUBLESPEED + const FileStat *pStatFromDir = bCached ? rDirEntry.ImpGetStat() : 0; + if ( pStatFromDir ) + { + nError = pStatFromDir->nError; + nKindFlags = pStatFromDir->nKindFlags; + nSize = pStatFromDir->nSize; + aCreator = pStatFromDir->aCreator; + aType = pStatFromDir->aType; + aDateCreated = pStatFromDir->aDateCreated; + aTimeCreated = pStatFromDir->aTimeCreated; + aDateModified = pStatFromDir->aDateModified; + aTimeModified = pStatFromDir->aTimeModified; + aDateAccessed = pStatFromDir->aDateAccessed; + aTimeAccessed = pStatFromDir->aTimeAccessed; + } + else +#endif + Update( rDirEntry, bFloppy ); +} + +/************************************************************************* +|* +|* FileStat::IsYounger() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 11.11.91 +|* Letzte Aenderung MA 11.11.91 +|* +*************************************************************************/ + +// TRUE wenn die Instanz j"unger als rIsOlder ist. +// FALSE wenn die Instanz "alter oder gleich alt wie rIsOlder ist. + +BOOL FileStat::IsYounger( const FileStat& rIsOlder ) const +{ + if ( aDateModified > rIsOlder.aDateModified ) + return TRUE; + if ( ( aDateModified == rIsOlder.aDateModified ) && + ( aTimeModified > rIsOlder.aTimeModified ) ) + return TRUE; + + return FALSE; +} + +/************************************************************************* +|* +|* FileStat::IsKind() +|* +|* Ersterstellung MA 11.11.91 (?) +|* Letzte Aenderung KH 16.01.95 +|* +*************************************************************************/ + +BOOL FileStat::IsKind( DirEntryKind nKind ) const +{ + BOOL bRet = ( ( nKind == FSYS_KIND_UNKNOWN ) && + ( nKindFlags == FSYS_KIND_UNKNOWN ) ) || + ( ( nKindFlags & nKind ) == nKind ); + return bRet; +} + +/************************************************************************* +|* +|* FileStat::HasReadOnlyFlag() +|* +|* Ersterstellung MI 06.03.97 +|* Letzte Aenderung UT 01.07.98 +|* +*************************************************************************/ + +BOOL FileStat::HasReadOnlyFlag() +{ +#if defined(WNT) || defined(OS2) || defined(UNX) + return TRUE; +#else + return FALSE; +#endif +} + +/************************************************************************* +|* +|* FileStat::GetReadOnlyFlag() +|* +|* Ersterstellung MI 06.03.97 +|* Letzte Aenderung UT 02.07.98 +|* +*************************************************************************/ + +BOOL FileStat::GetReadOnlyFlag( const DirEntry &rEntry ) +{ + + ByteString aFPath(rEntry.GetFull(), osl_getThreadTextEncoding()); +#ifdef WNT + DWORD nRes = GetFileAttributes( (LPCTSTR) aFPath.GetBuffer() ); + return ULONG_MAX != nRes && + ( FILE_ATTRIBUTE_READONLY & nRes ) == FILE_ATTRIBUTE_READONLY; +#endif + +#ifdef OS2 + FILESTATUS3 aFileStat; + APIRET nRet = DosQueryPathInfo( (PSZ)aFPath.GetBuffer(), 1, &aFileStat, sizeof(aFileStat) ); + switch ( nRet ) + { + case NO_ERROR: + return FILE_READONLY == ( aFileStat.attrFile & FILE_READONLY ); + + case ERROR_SHARING_VIOLATION: + return ERRCODE_IO_LOCKVIOLATION; + + default: + return ERRCODE_IO_NOTEXISTS; + } +#endif + +#ifdef UNX + /* could we stat the object? */ + struct stat aBuf; + if (stat(aFPath.GetBuffer(), &aBuf)) + return FALSE; + /* jupp, is writable for user? */ + return((aBuf.st_mode & S_IWUSR) != S_IWUSR); +#endif + return FALSE; +} + +/************************************************************************* +|* +|* FileStat::SetReadOnlyFlag() +|* +|* Ersterstellung MI 06.03.97 +|* Letzte Aenderung UT 01.07.98 +|* +*************************************************************************/ + +ULONG FileStat::SetReadOnlyFlag( const DirEntry &rEntry, BOOL bRO ) +{ + + ByteString aFPath(rEntry.GetFull(), osl_getThreadTextEncoding()); + +#ifdef WNT + DWORD nRes = GetFileAttributes( (LPCTSTR) aFPath.GetBuffer() ); + if ( ULONG_MAX != nRes ) + nRes = SetFileAttributes( (LPCTSTR) aFPath.GetBuffer(), + ( nRes & ~FILE_ATTRIBUTE_READONLY ) | + ( bRO ? FILE_ATTRIBUTE_READONLY : 0 ) ); + return ( ULONG_MAX == nRes ) ? ERRCODE_IO_UNKNOWN : 0; +#endif + +#ifdef OS2 + FILESTATUS3 aFileStat; + APIRET nRet = DosQueryPathInfo( (PSZ)aFPath.GetBuffer(), 1, &aFileStat, sizeof(aFileStat) ); + if ( !nRet ) + { + aFileStat.attrFile = ( aFileStat.attrFile & ~FILE_READONLY ) | + ( bRO ? FILE_READONLY : 0 ); + nRet = DosSetPathInfo( (PSZ)aFPath.GetBuffer(), 1, &aFileStat, sizeof(aFileStat), 0 ); + } + switch ( nRet ) + { + case NO_ERROR: + return ERRCODE_NONE; + + case ERROR_SHARING_VIOLATION: + return ERRCODE_IO_LOCKVIOLATION; + + default: + return ERRCODE_IO_NOTEXISTS; + } +#endif + +#ifdef UNX + /* first, stat the object to get permissions */ + struct stat aBuf; + if (stat(aFPath.GetBuffer(), &aBuf)) + return ERRCODE_IO_NOTEXISTS; + /* set or clear write bit for user */ + mode_t nMode; + if (bRO) + { + nMode = aBuf.st_mode & ~S_IWUSR; + nMode = aBuf.st_mode & ~S_IWGRP; + nMode = aBuf.st_mode & ~S_IWOTH; + } + else + nMode = aBuf.st_mode | S_IWUSR; + /* change it on fs */ + if (chmod(aFPath.GetBuffer(), nMode)) + { + switch (errno) + { + case EPERM : + case EROFS : + return ERRCODE_IO_ACCESSDENIED; + default : + return ERRCODE_IO_NOTEXISTS; + } + } + else + return ERRCODE_NONE; +#endif + return ERRCODE_IO_NOTSUPPORTED; +} + +/************************************************************************* +|* +|* FileStat::SetDateTime +|* +|* Ersterstellung PB 27.06.97 +|* Letzte Aenderung +|* +*************************************************************************/ +#if defined(WIN) | defined(WNT) | defined(OS2) + +void FileStat::SetDateTime( const String& rFileName, + const DateTime& rNewDateTime ) +{ + ByteString aFileName(rFileName, osl_getThreadTextEncoding()); + + Date aNewDate = rNewDateTime; + Time aNewTime = rNewDateTime; +#if defined(WIN) + unsigned date = 0; + unsigned time = 0; + + date = (unsigned) aNewDate.GetDay(); + date |= (unsigned)(aNewDate.GetMonth() << 5); + date |= (unsigned)((aNewDate.GetYear() - 1980) << 9); + time = (unsigned)(aNewTime.GetSec() / 2); + time |= (unsigned)(aNewTime.GetMin() << 5); + time |= (unsigned)(aNewTime.GetHour() << 11); + + + FILE* pFile = fopen( aFileName.GetBuffer(), "a" ); + + if ( pFile != NULL ) + { + _dos_setftime( fileno(pFile), date, time ); + fclose( pFile ); + } + +#elif defined( WNT ) + + TIME_ZONE_INFORMATION aTZI; + DWORD dwTZI = GetTimeZoneInformation( &aTZI ); + + if ( dwTZI != (DWORD)-1 && dwTZI != TIME_ZONE_ID_UNKNOWN ) + { + // 1. Korrektur der Zeitzone + short nDiff = (short)aTZI.Bias; + Time aOldTime = aNewTime; // alte Zeit merken + + // 2. evt. Korrektur Sommer-/Winterzeit + if ( dwTZI == TIME_ZONE_ID_DAYLIGHT ) + nDiff += (short)aTZI.DaylightBias; + + Time aDiff( abs( nDiff / 60 /*Min -> Std*/ ), 0 ); + + if ( nDiff > 0 ) + { + aNewTime += aDiff; // Stundenkorrektur + + // bei "Uberlauf korrigieren + if ( aNewTime >= Time( 24, 0 ) ) + aNewTime -= Time( 24, 0 ); + + // Tages"uberlauf? + if ( aOldTime == Time( 0, 0 ) || // 00:00 -> 01:00 + aNewTime < aOldTime ) // 23:00 -> 00:00 | 01:00 ... + aNewDate++; + } + else if ( nDiff < 0 ) + { + aNewTime -= aDiff; // Stundenkorrektur + + // negative Zeit (-1:00) korrigieren: 23:00 + if (aNewTime < Time( 0, 0 ) ) + aNewTime += Time( 24, 0 ); + + // Tagesunterlauf ? + if ( aOldTime == Time( 0, 0 ) || // 00:00 -> 23:00 + aNewTime > aOldTime ) // 01:00 -> 23:00 | 22:00 ... + aNewDate--; + } + } + + + SYSTEMTIME aTime; + aTime.wYear = aNewDate.GetYear(); + aTime.wMonth = aNewDate.GetMonth(); + aTime.wDayOfWeek = 0; + aTime.wDay = aNewDate.GetDay(); + aTime.wHour = aNewTime.GetHour(); + aTime.wMinute = aNewTime.GetMin(); + aTime.wSecond = aNewTime.GetSec(); + aTime.wMilliseconds = 0; + FILETIME aFileTime; + SystemTimeToFileTime( &aTime, &aFileTime ); + + HANDLE hFile = CreateFile( aFileName.GetBuffer(), GENERIC_WRITE, 0, 0, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 ); + + if ( hFile != INVALID_HANDLE_VALUE ) + { + SetFileTime( hFile, &aFileTime, &aFileTime, &aFileTime ); + CloseHandle( hFile ); + } + +#endif +#ifdef OS2 + // open file + ULONG nAction = FILE_EXISTED; + HFILE hFile = 0; + ULONG nFlags = OPEN_FLAGS_WRITE_THROUGH | + OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_CACHE | + OPEN_FLAGS_RANDOM | OPEN_FLAGS_NOINHERIT | + OPEN_SHARE_DENYNONE | OPEN_ACCESS_READWRITE; + + APIRET nRet = DosOpen((PSZ)aFileName.GetBuffer(), &hFile, (PULONG)&nAction, + 0/*size*/, FILE_NORMAL, + OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS, + nFlags, 0/*ea*/); + + if ( nRet == 0 ) + { + FILESTATUS3 FileInfoBuffer; + + nRet = DosQueryFileInfo( + hFile, 1, &FileInfoBuffer, sizeof(FileInfoBuffer)); + + if ( nRet == 0 ) + { + FDATE aNewDate; + FTIME aNewTime; + + // create date and time words + aNewDate.day = rNewDateTime.GetDay(); + aNewDate.month = rNewDateTime.GetMonth(); + aNewDate.year = rNewDateTime.GetYear() - 1980; + aNewTime.twosecs = rNewDateTime.GetSec() / 2; + aNewTime.minutes = rNewDateTime.GetMin(); + aNewTime.hours = rNewDateTime.GetHour(); + + // set file date and time + FileInfoBuffer.fdateCreation = aNewDate; + FileInfoBuffer.ftimeCreation = aNewTime; + FileInfoBuffer.fdateLastAccess = aNewDate; + FileInfoBuffer.ftimeLastAccess = aNewTime; + FileInfoBuffer.fdateLastWrite = aNewDate; + FileInfoBuffer.ftimeLastWrite = aNewTime; + + DosSetFileInfo(hFile, 1, &FileInfoBuffer, sizeof(FileInfoBuffer)); + } + DosClose(hFile); + } +#endif +} + +#endif +/* +FileStatMembers *FileStat::GetAllMembers() +{ + FileStatMembers *members = new FileStatMembers; + members->nError = nError; + members->nKindFlags = nKindFlags; + members->nSize = nSize; + members->aCreator = aCreator; + members->aType = aType; + members->aDateCreated = aDateCreated.GetDate(); + members->aTimeCreated = aTimeCreated.GetTime(); + members->aDateAccessed = aDateAccessed.GetDate(); + members->aTimeAccessed = aTimeAccessed.GetTime(); + members->aDateModified = aDateModified.GetDate(); + members->aTimeModified = aTimeModified.GetTime(); + return members; +} + +void FileStat::InitMembers(FileStatMembers *members) +{ + nError = members->nError; + members->nKindFlags = nKindFlags; + members->nSize = nSize; + members->aCreator = aCreator; + members->aType = aType; + aDateCreated.SetDate(members->aDateCreated); + aTimeCreated.SetTime(members->aTimeCreated); + aDateAccessed.SetDate(members->aDateAccessed); + aTimeAccessed.SetTime(members->aTimeAccessed); + aDateModified.SetDate(members->aDateModified); + aTimeModified.SetTime(members->aTimeModified); +} +*/ + + diff --git a/tools/source/fsys/makefile.mk b/tools/source/fsys/makefile.mk new file mode 100644 index 000000000000..432ad2a1d8c4 --- /dev/null +++ b/tools/source/fsys/makefile.mk @@ -0,0 +1,98 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=fsys + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= \ + $(SLO)$/tempfile.obj \ + $(SLO)$/wldcrd.obj \ + $(SLO)$/fstat.obj \ + $(SLO)$/comdep.obj \ + $(SLO)$/filecopy.obj \ + $(SLO)$/dirent.obj \ + $(SLO)$/tdir.obj \ + $(SLO)$/urlobj.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/wldcrd.obj \ + $(OBJ)$/fstat.obj \ + $(OBJ)$/comdep.obj \ + $(OBJ)$/filecopy.obj \ + $(OBJ)$/dirent.obj \ + $(OBJ)$/tdir.obj \ + $(OBJ)$/urlobj.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/fsys/os2.cxx b/tools/source/fsys/os2.cxx new file mode 100644 index 000000000000..f65956b7926e --- /dev/null +++ b/tools/source/fsys/os2.cxx @@ -0,0 +1,1153 @@ +/************************************************************************* + * + * $RCSfile: os2.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define INCL_DOSEXCEPTIONS + +#ifdef __BORLANDC__ +#include <alloc.h> +#else +#include <malloc.h> +#endif + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _LIST_HXX +#include <list.hxx> +#endif +#ifndef _BIGINT_HXX +#include <bigint.hxx> +#endif +#ifndef _FSYS_HXX +#include <fsys.hxx> +#endif +#include "comdep.hxx" + +#ifdef OS2 +#ifndef _VOS_MUTEX_HXX //autogen +#include <vos/mutex.hxx> +#endif +#endif + +int Sys2SolarError_Impl( int nSysErr ); + +DECLARE_LIST( DirEntryList, DirEntry* ); +DECLARE_LIST( FSysSortList, FSysSort* ); +DECLARE_LIST( FileStatList, FileStat* ); + +static char sCaseMap[256]; +static BOOL bCaseMap = FALSE; +static BOOL bDriveMap = FALSE; + +struct DriveMapItem +{ + DirEntryKind nKind; + char cName; + FSysPathStyle nStyle; +}; + +void CreateCaseMapImpl(); +void CreateDriveMapImpl(); + +static DriveMapItem aDriveMap[26]; + +static String sLastCaseSensitiveDir = ""; +static BOOL bLastCaseSensitive = FALSE; + +//==================================================================== + +int ApiRet2ToSolarError_Impl( int nApiRet ) +{ + switch ( nApiRet ) + { + case NO_ERROR: return ERRCODE_NONE; + case ERROR_FILE_NOT_FOUND: return ERRCODE_IO_NOTEXISTS; + case ERROR_PATH_NOT_FOUND: return ERRCODE_IO_NOTEXISTSPATH; + case ERROR_TOO_MANY_OPEN_FILES: return ERRCODE_IO_TOOMANYOPENFILES; + case ERROR_ACCESS_DENIED: return ERRCODE_IO_ACCESSDENIED; + case ERROR_NOT_ENOUGH_MEMORY: return ERRCODE_IO_OUTOFMEMORY; + case ERROR_BAD_FORMAT: return ERRCODE_IO_WRONGFORMAT; + case ERROR_NOT_SAME_DEVICE: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_WRITE_PROTECT: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_BAD_UNIT: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_CRC: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_NOT_DOS_DISK: return ERRCODE_IO_INVALIDDEVICE; + case ERROR_WRITE_FAULT: return ERRCODE_IO_CANTWRITE; + case ERROR_READ_FAULT: return ERRCODE_IO_CANTREAD; + case ERROR_SHARING_VIOLATION: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_LOCK_VIOLATION: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_WRONG_DISK: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_HANDLE_DISK_FULL: return ERRCODE_IO_OUTOFSPACE; + case ERROR_NOT_SUPPORTED: return ERRCODE_IO_NOTSUPPORTED; + case ERROR_DUP_NAME: return ERRCODE_IO_ALREADYEXISTS; + case ERROR_BAD_NETPATH: return ERRCODE_IO_NOTEXISTSPATH; + case ERROR_DEV_NOT_EXIST: return ERRCODE_IO_NOTEXISTS; + case ERROR_NETWORK_ACCESS_DENIED: return ERRCODE_IO_ACCESSDENIED; + case ERROR_INVALID_PARAMETER: return ERRCODE_IO_INVALIDPARAMETER; + case ERROR_NET_WRITE_FAULT: return ERRCODE_IO_CANTWRITE; + case ERROR_DEVICE_IN_USE: return ERRCODE_IO_INVALIDPARAMETER; + case ERROR_DISK_FULL: return ERRCODE_IO_OUTOFSPACE; + case ERROR_BAD_ARGUMENTS: return ERRCODE_IO_INVALIDPARAMETER; + case ERROR_BAD_PATHNAME: return ERRCODE_IO_NOTEXISTSPATH; + case ERROR_LOCK_FAILED: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_LOCKED: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_DUPLICATE_NAME: return ERRCODE_IO_ALREADYEXISTS; + case ERROR_DIRECTORY_IN_CDS: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_CURRENT_DIRECTORY: return ERRCODE_IO_LOCKVIOLATION; + case ERROR_FILENAME_EXCED_RANGE: return ERRCODE_IO_NAMETOOLONG; + } + + DBG_TRACE1( "FSys: unknown apiret error %d occured", nApiRet ); + return FSYS_ERR_UNKNOWN; +} + +//-------------------------------------------------------------------- + +DIR *opendir( const char* pPfad ) +{ + DIR *pDir = new DIR; + if ( pDir ) + pDir->p = (char*) pPfad; + return pDir; +} + +struct dirent *readdir( DIR *pDir ) +{ + APIRET nRet; + ULONG nCount = 1; + if ( pDir->p ) + { + char *pBuf = new char[ strlen( pDir->p ) + 5 ]; + if ( pBuf ) + { + // *.* dahinter, ggf mit "\\" abtrennen (falls nicht schon da) + strcpy( pBuf, pDir->p ); + strcat( pBuf, "\\*.*" + ( *(pBuf + strlen( pBuf ) - 1 ) == '\\' ) ); + pDir->aDirHdl = HDIR_SYSTEM; + nRet = DosFindFirst( (PSZ) pBuf, &pDir->aDirHdl, 23, + (PVOID) &pDir->aDirEnt, sizeof( FILEFINDBUF3 ), + &nCount, FIL_STANDARD ); + pDir->p = NULL; + delete pBuf; + } + else + nRet = 1; + } + else + { + nRet = DosFindNext( pDir->aDirHdl, + (PVOID) &pDir->aDirEnt, sizeof( pDir->aDirEnt ), + &nCount ); + } + + return !nRet ? &pDir->aDirEnt : NULL; +} + +int closedir( DIR *pDir ) +{ + if ( pDir ) + { + if ( !pDir->p ) + DosFindClose( pDir->aDirHdl ); + delete pDir; + } + return (pDir != NULL); +} + +typedef struct _FSInfo +{ + ULONG nSerial; + BYTE nNameLen; + UCHAR sName[40]; +} FSInfo; + +char* volumeid( const char* pPfad ) +{ + static FSInfo aFSInfoBuf; + + ULONG ulFSInfoLevel = FSIL_VOLSER; + ULONG nDriveNumber; + + nDriveNumber = toupper(*pPfad) - 'A' + 1; + + if ( nDriveNumber >= 3 ) + { + APIRET rc = DosQueryFSInfo( + nDriveNumber, ulFSInfoLevel, &aFSInfoBuf, sizeof(FSInfo) ); + if ( rc ) + return 0; + return (char*) aFSInfoBuf.sName; + } + return 0; +} + +/************************************************************************* +|* +|* DirEntry::ToAbs() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 13:30 +|* +*************************************************************************/ + +BOOL DirEntry::ToAbs() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if (paVirtualURL) + { + return TRUE; + } + + if ( FSYS_FLAG_VOLUME == eFlag ) + { + eFlag = FSYS_FLAG_ABSROOT; + return TRUE; + } + + if ( IsAbs() ) + return TRUE; + + char sBuf[512]; + + // Device bestimmen + DirEntry* pTop = ImpGetTopPtr(); + ULONG nDev, nMap; + if ( ( pTop->eFlag == FSYS_FLAG_VOLUME || pTop->eFlag == FSYS_FLAG_RELROOT ) && + pTop->aName.Len() ) + nDev = tolower(aName(0)) - 'a' + 1; + else + DosQueryCurrentDisk( &nDev, &nMap ); + + // das dortige CWD ermitteln; + ULONG nLen = sizeof( sBuf ) - 1; + DirEntry *pCWD = 0; + DosQueryCurrentDir( nDev, (PSZ) sBuf, &nLen ); + if ( sBuf[0] == 0 ) + strcpy( sBuf, "\\" ); + else + pCWD = new DirEntry( String( sBuf ) ); + + // das Device voranstellen + String aTempStr( (char)(nDev + 'a' - 1) ); + aTempStr += ':'; + if ( pCWD ) + pCWD->ImpGetTopPtr()->pParent = + new DirEntry( aTempStr, FSYS_FLAG_ABSROOT, DEFSTYLE ); + else + pCWD = new DirEntry( aTempStr, FSYS_FLAG_ABSROOT, DEFSTYLE ); + + // die relative Root durch ihr aktuelles Verzeichnis ersetzen + if ( pTop == this && + ( pTop->eFlag == FSYS_FLAG_RELROOT || pTop->eFlag == FSYS_FLAG_VOLUME ) ) + { + *pTop = *pCWD; + delete pCWD; + } + else if ( pTop->eFlag == FSYS_FLAG_ABSROOT ) + { + pTop->aName = aTempStr; + delete pCWD; + } + else + { + // dir\\..-Sequenzen aufloesen + while ( (pTop = ImpGetTopPtr())->eFlag == FSYS_FLAG_PARENT && + pTop != this ) + { + pCWD->CutName(); + ImpGetPreTopPtr()->pParent = 0; + delete pTop; + } + + // Pfad davorhaengen + if ( pTop == this && eFlag == FSYS_FLAG_PARENT ) + { + *this = pCWD->GetPath(); + delete pCWD; + } + else + ImpGetTopPtr()->pParent = pCWD; + } + + return IsAbs(); +} + +/************************************************************************* +|* +|* DirEntry::GetVolume() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 04.03.92 +|* Letzte Aenderung MI 04.03.92 +|* +*************************************************************************/ + +String DirEntry::GetVolume() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + const DirEntry *pTop = ImpGetTopPtr(); + + if ( pTop->eFlag == FSYS_FLAG_ABSROOT || + pTop->eFlag == FSYS_FLAG_VOLUME ) + { + const char *pVol; + pVol = volumeid( (char*) pTop->aName.GetStr() ); + return FSYS2GUI( String( pVol ? pVol : "" ) ); + } + + return String(); +} + +/************************************************************************* +|* +|* DirEntry::SetCWD() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 21.05.92 +|* +*************************************************************************/ + +BOOL DirEntry::SetCWD( BOOL bSloppy ) +{ + if (paVirtualURL) + { + String aTempString(GetRealPathFromVirtualURL()); + if (aTempString.Len()==0) + { + return FALSE; + } + DirEntry aTempDirEntry(aTempString); + return aTempDirEntry.SetCWD(bSloppy); + } + + // is the device to be changed? + DirEntry *pTop = ImpGetTopPtr(); + if ( ( pTop->eFlag == FSYS_FLAG_ABSROOT || + pTop->eFlag == FSYS_FLAG_RELROOT || pTop->eFlag == FSYS_FLAG_VOLUME ) + && pTop->aName.Len() ) + if ( DosSetDefaultDisk( pTop->aName.Lower()(0)-'a'+1 ) ) + return FALSE; + + APIRET nRet = DosSetCurrentDir( (PSZ) (const char *) GetFull() ); + if ( nRet && bSloppy ) + nRet = DosSetCurrentDir( (PSZ) (const char *) GetPath().GetFull() ); + return !nRet; +} + +/************************************************************************* +|* +|* DirEntry::MoveTo() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 14:07 +|* +*************************************************************************/ + +BOOL createLongNameEA( const PCSZ pszPath, ULONG ulAttributes, const String& aLongName ); + +FSysError DirEntry::MoveTo( const DirEntry& rDest ) const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aTmpDest(rDest); + FileStat aTmpStat(aTmpDest); + if ( aTmpStat.IsKind(FSYS_KIND_DIR) ) + aTmpDest += DirEntry( GetName() ); + + String aSource( GetFull() ); + String aDest( aTmpDest.GetFull() ); + String aShortSource(""); + String aShortDest(""); + + if (Folder::IsAvailable()) + { + if (IsLongNameOnFAT()) + { + // in kurzen Pfad wandeln + ItemIDPath aItemIDPath(aSource); + aShortSource = aItemIDPath.GetHostNotationPath(); + } + if (rDest.IsLongNameOnFAT()) + { + // in kurzen Pfad wandeln + ItemIDPath aItemIDPath(aDest); + aShortDest = aItemIDPath.GetHostNotationPath(); + } + } + + APIRET nRet = DosMove( aShortSource.Len()>0?(PSZ)aShortSource.GetStr():(PSZ)aSource.GetStr(), + aShortDest.Len()>0?(PSZ)aShortDest.GetStr():(PSZ)aDest.GetStr()); + + if ( nRet == ERROR_DIRECTORY_IN_CDS || + nRet == ERROR_CURRENT_DIRECTORY ) + { + // 2nd chance with modified CWD + DosSetCurrentDir( (PSZ) "\\" ); + nRet = DosMove( aShortSource.Len()>0?(PSZ)aShortSource.GetStr():(PSZ)aSource.GetStr(), + aShortDest.Len()>0?(PSZ)aShortDest.GetStr():(PSZ)aDest.GetStr()); + } + else if ( nRet == ERROR_NOT_SAME_DEVICE ) + { + // other volume => copy+delete + FileCopier aMover( *this, rDest ); + nRet = aMover.Execute( FSYS_ACTION_MOVE|FSYS_ACTION_RECURSIVE ); + return nRet; + } + + if ( (nRet==NO_ERROR) && aShortDest.Len()>0) + { + createLongNameEA((const char*)aShortDest, FILE_NORMAL, rDest.GetName()); + } + + return ApiRet2ToSolarError_Impl( nRet ); +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Init() +{ + USHORT nRead = 0; + if ( pDir->eAttrMask & FSYS_KIND_BLOCK ) + { + CreateDriveMapImpl(); + DirEntry aCurrentDir; + aCurrentDir.ToAbs(); + char sDrive[3] = "?:"; + + for ( char c = START_DRV; c <= 'z'; c++ ) + { + sDrive[0] = c; + DirEntry* pDrive = new DirEntry( sDrive, + FSYS_FLAG_VOLUME, FSYS_STYLE_HOST ); + if ( aDriveMap[c-'a'].nKind != FSYS_KIND_UNKNOWN && + pDir->aNameMask.Matches( sDrive ) ) + { + if ( pDir->pStatLst ) //Status fuer Sort gewuenscht? + { + FileStat *pNewStat = new FileStat( *pDrive ); + pDir->ImpSortedInsert( pDrive, pNewStat ); + } + else + pDir->ImpSortedInsert( pDrive, NULL ); + ++nRead; + } + else + delete pDrive; + } + + aCurrentDir.SetCWD(); + + } + +// OS2 ist beim Directory auslesen nicht threadfest +#ifdef OS2 + static NAMESPACE_VOS( OMutex )* pMutex = 0; + if( !pMutex ) pMutex = new NAMESPACE_VOS( OMutex ); + NAMESPACE_VOS( OGuard ) aGuard( pMutex ); +#endif + // Workaround: kein async-read, da OS/2 dann nix mehr liefert + for ( USHORT nLastRead; nLastRead = Read(); ) + nRead += nLastRead; + + return nRead; +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Read() +{ + // Directories und Files auflisten? + if ( ( pDir->eAttrMask & FSYS_KIND_DIR || pDir->eAttrMask & FSYS_KIND_FILE ) && + ( ( pDosEntry = readdir( pDosDir ) ) != NULL ) ) + { + if ( ( ( ( pDir->eAttrMask & FSYS_KIND_DIR ) && + ( pDosEntry->d_type & DOS_DIRECT ) ) || + ( ( pDir->eAttrMask & FSYS_KIND_FILE ) && + !( pDosEntry->d_type & DOS_DIRECT ) ) ) && + pDir->aNameMask.Matches( + ToLowerImpl( String( pDosEntry->d_name ) ) ) ) + { + String aName( FSYS2GUI( pDosEntry->d_name ) ); + DirEntryFlag eFlag = + aName == "." ? FSYS_FLAG_CURRENT + : aName == ".." ? FSYS_FLAG_PARENT + : FSYS_FLAG_NORMAL; + DirEntry *pTemp = new DirEntry( String( aName ), + eFlag, FSYS_STYLE_NTFS ); + if ( pParent ) + pTemp->ImpChangeParent( new DirEntry( *pParent ), FALSE ); + if ( pDir->pStatLst ) //Status fuer Sort gewuenscht? + { + FileStat *pNewStat = new FileStat( (void*) pDosDir, (void*) 0 ); + pDir->ImpSortedInsert( pTemp, pNewStat ); + } + else + pDir->ImpSortedInsert( pTemp, NULL ); + return 1; + } + } + else + bReady = TRUE; + return 0; +} + +/************************************************************************* +|* +|* FileStat::FileStat() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 05.11.91 +|* Letzte Aenderung MA 07.11.91 +|* +*************************************************************************/ + +FileStat::FileStat( const void *pInfo, // struct dirent + const void * ): // dummy + aDateCreated(0), + aTimeCreated(0), + aDateModified(0), + aTimeModified(0), + aDateAccessed(0), + aTimeAccessed(0) +{ + paVirtualURL = NULL; + + struct dirent *pDirent = (struct dirent*) pInfo; + + nSize = pDirent->d_size; + + aDateCreated = MsDos2Date( pDirent->d_date ); + aTimeCreated = MsDos2Time( pDirent->d_time ); + aDateModified = aDateModified; + aTimeModified = aTimeModified; + aDateAccessed = aDateModified; + aTimeAccessed = aTimeModified; + + nKindFlags = FSYS_KIND_FILE; + if ( pDirent->d_type & DOS_DIRECT ) + nKindFlags = FSYS_KIND_DIR; +} + +/************************************************************************* +|* +|* FileStat::Update() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 11.06.91 +|* Letzte Aenderung MA 07.11.91 +|* +*************************************************************************/ + +struct _FSYS_FSQBUFFER +{ + FSQBUFFER2 aBuf; + UCHAR sBuf[256]; +}; + +BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bAccessRemovableDevice ) +{ + paVirtualURL = rDirEntry.paVirtualURL; + + nSize = 0; + FSysPathStyle eStyle = FSYS_STYLE_UNKNOWN; + aCreator.Erase(); + aType.Erase(); + aDateCreated = Date(0); + aTimeCreated = Time(0); + aDateModified = Date(0); + aTimeModified = Time(0); + aDateAccessed = Date(0); + aTimeAccessed = Time(0); + + if (paVirtualURL) + { + if (rDirEntry.GetRealPathFromVirtualURL().Len()==0) + { + // keine reale repräsentation für VirtualURL, also alles setzen, + // lediglich dir/file unterscheidbar + nKindFlags = FSYS_KIND_ALL; + + if (Folder(ItemIDPath(rDirEntry.GetFull())).IsValid()) //ist dir? + { + nKindFlags &= ~FSYS_KIND_FILE; //ja, also kein file + } + else + { + nKindFlags &= ~FSYS_KIND_DIR; //nein, also kein dir + } + + nError = FSYS_ERR_OK; + return TRUE; + } + } + + nError = rDirEntry.IsValid() ? FSYS_ERR_OK : FSYS_ERR_UNKNOWN; + if ( nError > FSYS_ERR_OK ) + return FALSE; + + // Sonderbehandlung falls es sich um eine Wildcard handelt + String aTempName( rDirEntry.GetName() ); + if ( strchr( (char*) (const char*) aTempName, '?' ) || + strchr( (char*) (const char*) aTempName, '*' ) || + strchr( (char*) (const char*) aTempName, ';' ) ) + { + nKindFlags = FSYS_KIND_WILD; + nError = FSYS_ERR_OK; + return TRUE; + } + + // Sonderbehandlung falls es sich um eine Root handelt + if ( rDirEntry.eFlag == FSYS_FLAG_VOLUME || + rDirEntry.eFlag == FSYS_FLAG_ABSROOT ) + { + if ( rDirEntry.eFlag == FSYS_FLAG_VOLUME ) + nKindFlags = FSYS_KIND_DEV; + else + nKindFlags = FSYS_KIND_DIR; + + if ( rDirEntry.aName.Len() == 2 ) + { + if ( !bDriveMap ) + CreateDriveMapImpl(); + + DriveMapItem &rItem = aDriveMap[toupper(rDirEntry.aName[0]) - 'A']; + if ( !rItem.nKind ) + { + nError = ERRCODE_IO_INVALIDDEVICE; + nKindFlags = FSYS_KIND_UNKNOWN; + return FALSE; + } + else + { + if ( rDirEntry.eFlag == FSYS_FLAG_VOLUME ) + nKindFlags |= FSYS_KIND_BLOCK | rItem.nKind; + eStyle = rItem.nStyle; + } + } + + nError = FSYS_ERR_OK; + return TRUE; + } + + // disable error-boxes for hard-errors + DosError(FERR_DISABLEHARDERR); + + // Statusinformation vom Betriebssystem holen + DirEntry aTempDirEntry( rDirEntry ); + char* p; + String aFullName; + + aTempDirEntry.ToAbs(); + aFullName = aTempDirEntry.GetFull(); + + if (aTempDirEntry.paVirtualURL) + { + aFullName = rDirEntry.GetRealPathFromVirtualURL(); + } + + if (Folder::IsAvailable() && aTempDirEntry.IsLongNameOnFAT()) + { + // in String mit kurzem Pfad wandeln + ItemIDPath aItemIDPath(aTempDirEntry.GetFull()); + aFullName = aItemIDPath.GetHostNotationPath(); + } + + p = (char *) aFullName.GetStr(); + + FILESTATUS3 filestat; + memset( &filestat, 0, sizeof( filestat ) ); + if( DosQueryPathInfo( (PSZ)p, 1, &filestat, sizeof( filestat ) ) ) + { + nError = FSYS_ERR_NOTEXISTS; + nKindFlags = FSYS_KIND_UNKNOWN; + return FALSE; + } + + nError = FSYS_ERR_OK; + nSize = filestat.cbFile; + + nKindFlags = FSYS_KIND_UNKNOWN; + if( filestat.attrFile & FILE_DIRECTORY ) + nKindFlags |= FSYS_KIND_DIR; + if ( nKindFlags == FSYS_KIND_UNKNOWN ) + nKindFlags = nKindFlags | FSYS_KIND_FILE; + + aDateModified = Date( filestat.fdateLastWrite.day, + filestat.fdateLastWrite.month, + filestat.fdateLastWrite.year + 1980 ); + + aTimeModified = Time( filestat.ftimeLastWrite.hours, + filestat.ftimeLastWrite.minutes, + filestat.ftimeLastWrite.twosecs*2 ); + + if ( filestat.fdateCreation.day ) + { + aDateCreated = Date( filestat.fdateCreation.day, + filestat.fdateCreation.month, + filestat.fdateCreation.year + 1980 ); + + aTimeCreated = Time( filestat.ftimeCreation.hours, + filestat.ftimeCreation.minutes, + filestat.ftimeCreation.twosecs*2 ); + } + else + { + aDateCreated = aDateModified; + aTimeCreated = aTimeModified; + } + + if ( filestat.fdateLastAccess.day > 0 ) + { + aDateAccessed = Date( filestat.fdateLastAccess.day, + filestat.fdateLastAccess.month, + filestat.fdateLastAccess.year + 1980 ); + + aTimeAccessed = Time( filestat.ftimeLastAccess.hours, + filestat.ftimeLastAccess.minutes, + filestat.ftimeLastAccess.twosecs*2 ); + } + else + { + aDateAccessed = aDateModified; + aTimeAccessed = aTimeModified; + } + + return TRUE; +} + +#if SUPD>364 +BOOL IsRedirectable_Impl( const String &rPath ) +{ + if ( rPath.Len() >= 3 && ':' == rPath.GetStr()[1] ) + { + DriveMapItem &rItem = aDriveMap[toupper(rPath[0]) - 'A']; + return FSYS_KIND_FIXED != rItem.nKind; + } + return FALSE; +} +#endif + +const char* TempDirImpl( char *pBuf ) +{ +#if defined( __BORLANDC__ ) && (__BORLANDC__ < 0x0460) + PSZ pVar; +#else + PCSZ pVar; +#endif + USHORT nRet; + BOOL bAppendTemp = FALSE; // mu\s noch \\temp angeh"angt werden + + // Erstmal sehen, ob TEMP oder TMP gesetzt sind + nRet = DosScanEnv( (PSZ)"TEMP", &pVar ); + if( nRet ) + nRet = DosScanEnv( (PSZ)"temp", &pVar ); + if( nRet ) + nRet = DosScanEnv( (PSZ)"TMP", &pVar ); + if( nRet ) + nRet = DosScanEnv( (PSZ)"tmp", &pVar ); + + // falls das geklappt hat, und ein Backslash dranhaengt, + // oder falls es bisher nicht geklappt hat, + // muessen wir nachher einen Backslash entfernen + BOOL bRemoveBS = nRet || *(pVar+strlen(pVar)-1) == '\\'; + + // Keine temp-Variable gefunden, dann gehen wir mal auf die Suche + // nach dem System-Laufwerk + if( nRet ) + { + nRet = DosScanEnv( (PSZ)"USER_INI",&pVar ); + bAppendTemp = (0 == nRet); + } + if( nRet ) + { + nRet = DosScanEnv( (PSZ)"SYSTEM_INI", &pVar ); + bAppendTemp = (0 == nRet); + } + if( nRet ) + // Wenn das immer noch nicht reicht nehmen wir eben die Root von C: +#ifdef __BORLANDC__ + pVar = (PSZ)"c:\\temp\\"; +#else + pVar = (PCSZ)"c:\\temp\\"; +#endif + strcpy( pBuf, (const char*)pVar ); + + // jetzt haengt ggf. ein Backlash dran, den wir abschneiden, + // ggf. inklusive dahinter haengendem Dateinamen + if ( bRemoveBS ) + { + char *pTail = pBuf + strlen(pBuf) - 1; + for ( char cLast = *pTail; cLast != '\\'; cLast = *(--pTail) ) + *pTail = 0; + } + + if ( bAppendTemp ) + strcat( pBuf, "\\temp" ); + DirEntry( pBuf ).MakeDir(); + + return pBuf; +} + +#define CURRENT_COUNTRY 0 +#define NLS_CODEPAGE 850 + +/*==================================================================== + * CreateCaseMapImpl() + * creates a map of each character to convert to lower + *--------------------------------------------------------------------*/ + +void CreateCaseMapImpl() +{ + // build a string starting with code 0 as first character upto 255 + char sTemp[256]; + for ( USHORT n = 0; n < 256; ++n ) + sTemp[n] = (char) n; + + // convert string to upper case + COUNTRYCODE aCountry; + aCountry.country = CURRENT_COUNTRY; /* Country code */ + aCountry.codepage = NLS_CODEPAGE; /* Code page */ + DosMapCase( 255, &aCountry, sTemp+1 ); + + // fill a global buffer starting with code 0 as first character upto 255 + for ( n = 0; n < 256; ++n ) + sCaseMap[n] = (char) n; + + // reorder by upper-code and store in a global buffer + for ( n = 255; n > 0; --n ) + // was this character converted? + if ( sTemp[n] != (char) n ) + // we found a convertion from upper to lower + sCaseMap[ (unsigned char) sTemp[n] ] = (char) n; + + bCaseMap = TRUE; +} + +String ToLowerImpl( const String& rSource ) +{ + if ( !bCaseMap ) + CreateCaseMapImpl(); + + // TH sagt: International ist zu langsam, also mit einer eigenen Map + String aLower( rSource ); + for ( USHORT n = 0; n < aLower.Len(); ++n ) + aLower[n] = sCaseMap[ (unsigned char) aLower[n] ]; + return aLower; +} + +/*==================================================================== + * CreateDriveMapImpl() + * creates a map of drive-infos like FileSystem (style) and Kind (remote) + *--------------------------------------------------------------------*/ + +typedef struct _FSQBUFFER_ +{ + FSQBUFFER2 aBuf; + UCHAR sBuf[64]; +} FSQBUFFER_; + +void CreateDriveMapImpl() +{ +#ifdef POWERPC + // !!!!! Hack, da der untere Teil mit Beta 2 noch abstuertzt !!!!! + BYTE nFloppies = 1; + for ( USHORT nDrive = 0; nDrive < 26; ++nDrive ) + { + if ( nDrive < nFloppies ) + { + aDriveMap[nDrive].nKind = FSYS_KIND_REMOVEABLE; + aDriveMap[nDrive].nStyle = FSYS_STYLE_FAT; + } + else + { + aDriveMap[nDrive].nKind = FSYS_KIND_UNKNOWN; + aDriveMap[nDrive].nStyle = FSYS_STYLE_UNKNOWN; + } + } + + aDriveMap[2].nKind = FSYS_KIND_FIXED; + aDriveMap[2].nStyle = FSYS_STYLE_FAT; +#else + FSQBUFFER_ aBuf; + ULONG nBufLen; + APIRET nRet; + + // disable error-boxes for hard-errors + DosError(FERR_DISABLEHARDERR); + + // determine number of floppy-drives + BYTE nFloppies; + nRet = DosDevConfig( (void*) &nFloppies, DEVINFO_FLOPPY ); + + // reset the map + for ( USHORT nDrive = 0; nDrive < 26; ++nDrive ) + { + if ( nDrive < nFloppies ) + { + aDriveMap[nDrive].nKind = FSYS_KIND_REMOVEABLE; + aDriveMap[nDrive].nStyle = FSYS_STYLE_FAT; + } + else + { + aDriveMap[nDrive].nKind = FSYS_KIND_UNKNOWN; + aDriveMap[nDrive].nStyle = FSYS_STYLE_UNKNOWN; + } + } + + // determine file-system via DosOpen/DocDevIOCtrl + for ( nDrive = 2; nDrive < 26; ++nDrive ) + { + // open drive + BOOL bFixed; + HFILE nDevHandle; + char pDriveName[3] = "#:"; + pDriveName[0] = nDrive+'a'; + ULONG nAction; + nRet = DosOpen( (PSZ) pDriveName, &nDevHandle, + &nAction, 0, 0, OPEN_ACTION_OPEN_IF_EXISTS, + OPEN_FLAGS_DASD|OPEN_SHARE_DENYNONE|OPEN_ACCESS_READONLY, + 0 ); + + // exists? + if ( !nRet ) + { + // removeable? + BYTE nDriveId = nDrive; + ULONG nParaOutLen, nDataOutLen; + nRet = DosDevIOCtl(nDevHandle, 8, 0x20, + &nDriveId, sizeof(nDriveId), &nParaOutLen, + &bFixed, sizeof(bFixed), &nDataOutLen ); + + // prepare the drive-map + if ( !nRet && !bFixed ) + aDriveMap[nDrive].nKind = FSYS_KIND_REMOVEABLE; + + // close drive + DosClose(nDevHandle); + } + else if ( nRet == ERROR_NOT_READY ) + aDriveMap[nDrive].nKind = FSYS_KIND_REMOVEABLE | FSYS_KIND_CDROM; + } + + // determine file-system via FSAttach + nRet = 0; + for ( USHORT n = 3; nRet != ERROR_NO_MORE_ITEMS; ++n ) + { + nBufLen = sizeof( aBuf ); + nRet = DosQueryFSAttach( 0, n, FSAIL_DRVNUMBER, + (_FSQBUFFER2*) &aBuf, &nBufLen ); + if ( !nRet ) + { + nDrive = toupper(aBuf.aBuf.szName[0]) - 'A'; + + if ( aDriveMap[nDrive].nKind == FSYS_KIND_UNKNOWN ) + aDriveMap[nDrive].nKind = + aBuf.aBuf.iType == 3 ? FSYS_KIND_FIXED : + aBuf.aBuf.iType == 4 ? FSYS_KIND_REMOTE : + FSYS_KIND_UNKNOWN; + + char *pType = (char*)(aBuf.aBuf.szName + aBuf.aBuf.cbName + 1); + aDriveMap[nDrive].nStyle = + strcmp( pType, "FAT" ) == 0 ? FSYS_STYLE_FAT : + strcmp( pType, "HPFS" ) == 0 ? FSYS_STYLE_HPFS : + strcmp( pType, "NWFS" ) == 0 ? FSYS_STYLE_NWFS : + strcmp( pType, "EXT2" ) == 0 ? FSYS_STYLE_UNX : + strcmp( pType, "NFS" ) == 0 ? FSYS_STYLE_UNX : + FSYS_STYLE_UNKNOWN; + if ( strcmp( pType, "CDFS" ) == 0 ) + aDriveMap[nDrive].nKind = FSYS_KIND_CDROM|FSYS_KIND_REMOVEABLE; + } + } +#endif + + bDriveMap = TRUE; +} + +Time MsDos2Time( const time_t *pTimeT ) +{ + tm *pTm = localtime( pTimeT ); + if ( pTm ) + return Time( pTm->tm_hour, pTm->tm_min, pTm->tm_sec ); + else + return Time(0); +} + +Date MsDos2Date( const time_t *pTimeT ) +{ + tm *pTm = localtime( pTimeT ); + if ( pTm ) + return Date( pTm->tm_mday, pTm->tm_mon + 1, pTm->tm_year ); + else + return Date(0); +} + +/************************************************************************* +|* +|* DirEntry::GetPathStyle() const +|* +|* Beschreibung +|* Ersterstellung MI 11.05.95 +|* Letzte Aenderung MI 11.05.95 +|* +*************************************************************************/ + +FSysPathStyle DirEntry::GetPathStyle( const String &rDevice ) +{ + // UNC-Pathname? + if ( !rDevice || ( rDevice.Len() > 1 && rDevice[ (USHORT) 1] != ':' ) ) + return FSYS_STYLE_UNKNOWN; + + if ( !bDriveMap ) + CreateDriveMapImpl(); + return aDriveMap[toupper(rDevice[0]) - 'A'].nStyle; +} + +/************************************************************************* +|* +|* DirEntry::IsCaseSensitive() const +|* +|* Beschreibung +|* Ersterstellung TPF 26.02.1999 +|* Letzte Aenderung +|* +*************************************************************************/ + +BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const +{ + if (eFormatter==FSYS_STYLE_HOST) + { + if (GetPathStyle(GetDevice().GetName()) == FSYS_STYLE_UNX) + { + return TRUE; + } + else + { + return FALSE; + } + } + else + { + BOOL isCaseSensitive = FALSE; // ich bin unter OS2, also ist der default im Zweifelsfall case insensitiv + switch ( eFormatter ) + { + case FSYS_STYLE_MAC: + case FSYS_STYLE_FAT: + case FSYS_STYLE_VFAT: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + case FSYS_STYLE_HPFS: + case FSYS_STYLE_DETECT: + { + isCaseSensitive = FALSE; + break; + } + case FSYS_STYLE_SYSV: + case FSYS_STYLE_BSD: + { + isCaseSensitive = TRUE; + break; + } + default: + { + isCaseSensitive = FALSE; // ich bin unter OS2, also ist der default im Zweifelsfall case insensitiv + break; + } + } + return isCaseSensitive; + } +} + + + + +//========================================================================= + +ErrCode FileStat::QueryDiskSpace( const String &rPath, + BigInt &rFreeBytes, BigInt &rTotalBytes ) +{ + FSALLOCATE aFSInfoBuf; + String aVolume( DirEntry(rPath).ImpGetTopPtr()->GetName() ); + ULONG nDriveNumber = toupper( aVolume(0) ) - 'A' + 1; + + APIRET rc = DosQueryFSInfo( nDriveNumber, FSIL_ALLOC, + &aFSInfoBuf, sizeof(aFSInfoBuf) ); + if ( rc ) + return Sys2SolarError_Impl( rc ); + + BigInt aBytesPerCluster( BigInt(aFSInfoBuf.cbSector) * + BigInt(aFSInfoBuf.cSectorUnit) ); + rFreeBytes = aBytesPerCluster * BigInt(aFSInfoBuf.cUnitAvail); + rTotalBytes = aBytesPerCluster * BigInt(aFSInfoBuf.cUnit); + return 0; +} + +//========================================================================= + +void FSysEnableSysErrorBox( BOOL bEnable ) +{ + DosError( bEnable ? 0 : FERR_DISABLEHARDERR ); +} + diff --git a/tools/source/fsys/os2.hxx b/tools/source/fsys/os2.hxx new file mode 100644 index 000000000000..bc03d0e21582 --- /dev/null +++ b/tools/source/fsys/os2.hxx @@ -0,0 +1,151 @@ +/************************************************************************* + * + * $RCSfile: os2.hxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _os2_hxx +#define _os2_hxx + +#include <string.h> + +#include <sys\types.h> +#include <sys\stat.h> +#include <stdio.h> +#include <ctype.h> + +#define INCL_DOSEXCEPTIONS +#define INCL_DOSFILEMGR +#define INCL_DOSPROCESS +#define INCL_DOSDEVICES +#define INCL_DOSERRORS +#define INCL_DOSMISC +#define INCL_DOSNLS /* National Language Support values */ +#include <svpm.h> + +#include <string.hxx> + +#define FSYS_UNIX FALSE + +#define DOS_DIRECT 16 +#define setdrive(n,a) dos_setdrive(n,a) +#define GETDRIVE(n) dos_getdrive(&n) + +#define _mkdir(p) DosCreateDir( (PSZ)p, 0 ) +#define _rmdir(p) DosDeleteDir( (PSZ)p ) +#define _unlink(p) DosForceDelete( (PSZ)p ) +#define _chdir chdir +#define _getcwd getcwd +#define _access access + +const char* TempDirImpl( char *pBuf ); +String ToLowerImpl( const String& ); + +inline char *getcwd(char *p, ULONG nLen ) +{ + return DosQueryCurrentDir( 0, (PBYTE)p, &nLen ) ? p : 0; +} + +#define dirent _FILEFINDBUF3 +#define d_name achName +#define d_type attrFile +#define d_size cbFile +#define d_attr attrFile +#define d_date fdateLastWrite +#define d_time ftimeLastWrite + +typedef struct +{ + HDIR aDirHdl; + FILEFINDBUF3 aDirEnt; + char *p; +} DIR; + +#define DEFSTYLE FSYS_STYLE_OS2 +#define MKDIR( p ) mkdir( (unsigned char*) p ) +#define CMP_LOWER(aString) ToLowerImpl(aString) + +#define START_DRV 'a' + +inline BOOL DRIVE_EXISTS( char c ) +{ + ULONG nCur, nMap; + APIRET nRet = DosQueryCurrentDisk( &nCur, &nMap ); + return ( nMap & 1 << (c - 'a') ) != 0; +} + +#include <time.h> +#include <datetime.hxx> + +inline Time MsDos2Time( FTIME aTime ) +{ + return Time( aTime.hours, aTime.minutes, 2*aTime.twosecs ); +} + +inline Date MsDos2Date( FDATE aDate ) +{ + return Date( aDate.day, aDate.month, aDate.year ); +} + +Time MsDos2Time( const time_t *pTimeT ); + +Date MsDos2Date( const time_t *pTimeT ); + +#define FSysFailOnErrorImpl() + +#endif diff --git a/tools/source/fsys/tdir.cxx b/tools/source/fsys/tdir.cxx new file mode 100644 index 000000000000..021bed1f196e --- /dev/null +++ b/tools/source/fsys/tdir.cxx @@ -0,0 +1,808 @@ +/************************************************************************* + * + * $RCSfile: tdir.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _DIR_CXX + +#include <stdlib.h> +#include <stdarg.h> +#include <limits.h> + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _LIST_HXX +#include <list.hxx> +#endif + +#ifndef _COMPED_HXX +#include "comdep.hxx" +#endif +#ifndef _FSYS_HXX +#include <fsys.hxx> +#endif + + +DBG_NAME( Dir ); + +DECLARE_LIST( DirEntryList, DirEntry* ); +DECLARE_LIST( FSysSortList, FSysSort* ); +DECLARE_LIST( FileStatList, FileStat* ); + +#define APPEND (USHORT) 65535 + +/************************************************************************* +|* +|* Dir::InsertPointReached() +|* +|* Beschreibung stellt fest, ob eingefuegt werden musz +|* Ersterstellung MA 05.11.91 +|* Letzte Aenderung MI 05.02.92 +|* +*************************************************************************/ + +BOOL Dir::ImpInsertPointReached( const DirEntry& rNewEntry, + const FileStat& rNewStat, + ULONG nCurPos, ULONG nSortIndex ) const +{ +#define VALUE( nKindFlags ) \ + ( ( FSYS_KIND_FILE | FSYS_KIND_DIR | FSYS_KIND_DEV | \ + FSYS_KIND_CHAR | FSYS_KIND_BLOCK ) & nKindFlags ) + + // einfache Dinge erfordern einfache Loesungen + if ( !pLst->Count() ) + return TRUE; + + FSysSort nSort = *( pSortLst->GetObject( nSortIndex ) ); + FileStat *pOldStat = NULL; + DirEntry *pCurLstObj = pLst->GetObject( nCurPos ); + if ( pStatLst ) + pOldStat = pStatLst->GetObject( nCurPos ); + + switch( nSort ) + { + case FSYS_SORT_NAME: + case (FSYS_SORT_NAME | FSYS_SORT_ASCENDING): + if ( pCurLstObj->aName > rNewEntry.aName ) + return TRUE; + if ( !(pCurLstObj->aName == rNewEntry.aName) ) + return FALSE; + break; + case (FSYS_SORT_NAME | FSYS_SORT_DESCENDING): + if ( pCurLstObj->aName < rNewEntry.aName ) + return TRUE; + if ( !(pCurLstObj->aName == rNewEntry.aName) ) + return FALSE; + break; + + case FSYS_SORT_EXT: + case (FSYS_SORT_EXT | FSYS_SORT_ASCENDING): + { + if ( pCurLstObj->GetExtension() > rNewEntry.GetExtension() ) + return TRUE; + if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) ) + return FALSE; + break; + } + case (FSYS_SORT_EXT | FSYS_SORT_DESCENDING): + { + if ( pCurLstObj->GetExtension() < rNewEntry.GetExtension() ) + return TRUE; + if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) ) + return FALSE; + break; + } + + case FSYS_SORT_KIND: + case (FSYS_SORT_KIND | FSYS_SORT_ASCENDING ): + if ( VALUE(pOldStat->nKindFlags) > VALUE(rNewStat.nKindFlags) ) + return TRUE; + if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) ) + return FALSE; + break; + case (FSYS_SORT_KIND | FSYS_SORT_DESCENDING): + if ( VALUE(pOldStat->nKindFlags) < VALUE(rNewStat.nKindFlags) ) + return TRUE; + if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) ) + return FALSE; + break; + + case FSYS_SORT_SIZE: + case (FSYS_SORT_SIZE | FSYS_SORT_ASCENDING): + if ( pOldStat->nSize > rNewStat.nSize ) + return TRUE; + if ( !(pOldStat->nSize == rNewStat.nSize) ) + return FALSE; + break; + case (FSYS_SORT_SIZE | FSYS_SORT_DESCENDING): + if ( pOldStat->nSize < rNewStat.nSize ) + return TRUE; + if ( !(pOldStat->nSize == rNewStat.nSize) ) + return FALSE; + break; + + case FSYS_SORT_MODIFYED: + case (FSYS_SORT_MODIFYED | FSYS_SORT_ASCENDING): + if ( (pOldStat->aDateModified >= rNewStat.aDateModified) && + (pOldStat->aTimeModified > rNewStat.aTimeModified) ) + return TRUE; + if ( !((pOldStat->aDateModified == rNewStat.aDateModified) && + (pOldStat->aTimeModified == rNewStat.aTimeModified)) ) + return FALSE; + break; + case (FSYS_SORT_MODIFYED | FSYS_SORT_DESCENDING): + if ( (pOldStat->aDateModified <= rNewStat.aDateModified) && + (pOldStat->aTimeModified < rNewStat.aTimeModified) ) + return TRUE; + if ( !((pOldStat->aDateModified == rNewStat.aDateModified) && + (pOldStat->aTimeModified == rNewStat.aTimeModified)) ) + return FALSE; + break; + + case FSYS_SORT_CREATED: + case (FSYS_SORT_CREATED | FSYS_SORT_ASCENDING): + if ( (pOldStat->aDateCreated >= rNewStat.aDateCreated) && + (pOldStat->aTimeCreated > rNewStat.aTimeCreated) ) + return TRUE; + if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) && + (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) ) + return FALSE; + break; + case (FSYS_SORT_CREATED | FSYS_SORT_DESCENDING): + if ( (pOldStat->aDateCreated <= rNewStat.aDateCreated) && + (pOldStat->aTimeCreated < rNewStat.aTimeCreated) ) + return TRUE; + if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) && + (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) ) + return FALSE; + break; + + case FSYS_SORT_ACCESSED: + case (FSYS_SORT_ACCESSED | FSYS_SORT_ASCENDING): + if ( (pOldStat->aDateAccessed >= rNewStat.aDateAccessed) && + (pOldStat->aTimeAccessed > rNewStat.aTimeAccessed) ) + return TRUE; + if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) && + (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) ) + return FALSE; + break; + case (FSYS_SORT_ACCESSED | FSYS_SORT_DESCENDING): + if ( (pOldStat->aDateAccessed <= rNewStat.aDateAccessed) && + (pOldStat->aTimeAccessed < rNewStat.aTimeAccessed) ) + return TRUE; + if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) && + (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) ) + return FALSE; + break; + default: /* Kann nicht sein */; + } + + if ( nSortIndex == ( pSortLst->Count() - 1 ) ) + return TRUE; + else + //Rekursion + return ImpInsertPointReached( rNewEntry, rNewStat, + nCurPos, nSortIndex + 1 ); +#undef VALUE +} + +/************************************************************************* +|* +|* Dir::ImpSortedInsert() +|* +|* Beschreibung fuegt sortiert ein +|* Ersterstellung MA 05.11.91 +|* Letzte Aenderung MA 03.12.91 +|* +*************************************************************************/ + +void Dir::ImpSortedInsert( const DirEntry *pNewEntry, const FileStat *pNewStat ) +{ + //Sonderfall, keine Sortierung gewuenscht. + if ( !pSortLst ) { + pLst->Insert( (DirEntry*)pNewEntry, APPEND ); + return; + } + + pLst->First(); + do { + if ( ImpInsertPointReached( *pNewEntry, *pNewStat, pLst->GetCurPos(), + (ULONG)0 ) ) + { + if ( pStatLst ) + pStatLst->Insert( (FileStat*)pNewStat, pLst->GetCurPos() ); + pLst->Insert( (DirEntry*)pNewEntry ); + return; + } + } while( pLst->Next() ); + + if ( pStatLst ) + pStatLst->Insert( (FileStat*)pNewStat, APPEND ); + pLst->Insert( (DirEntry*)pNewEntry, APPEND ); +} + +/************************************************************************* +|* +|* Dir::Construct() +|* +|* Beschreibung gemeinsame Implementation der Ctoren +|* Ersterstellung MI 02.06.93 +|* Letzte Aenderung MI 02.06.93 +|* +*************************************************************************/ + +void Dir::Construct( DirEntryKind nKindFlags ) +{ + pLst = NULL; + pSortLst = NULL; + pStatLst = NULL; + eAttrMask = nKindFlags; + ByteString aTempName( GetName(), osl_getThreadTextEncoding() ); + if ( aTempName.Search( "*" ) != STRING_NOTFOUND || + aTempName.Search( "?" ) != STRING_NOTFOUND ) +#if defined( WNT ) && !defined( WTC ) + { + ByteString aTStr(CutName(), osl_getThreadTextEncoding()); + char* pBuffer = new char[aTStr.Len()+1]; + strcpy( pBuffer, aTStr.GetBuffer() ); + CharLowerBuff( pBuffer, aTStr.Len() ); + aNameMask = WildCard( String(pBuffer, osl_getThreadTextEncoding()), ';' ); + delete pBuffer; + } +#else + aNameMask = WildCard( CutName(), ';' ); +#endif + else + aNameMask = String("*", osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* Dir::Update() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MI 19.09.96 +|* +*************************************************************************/ + +BOOL Dir::Update() +{ + Reset(); + return Scan( USHRT_MAX ) > 0; +} + +/************************************************************************* +|* +|* Dir::Reset() +|* +|* Beschreibung +|* Ersterstellung MI 22.10.96 +|* Letzte Aenderung MI 22.10.96 +|* +*************************************************************************/ + +void Dir::Reset() +{ + // ggf. alten Reader l"oschen + if ( pReader && pReader->bInUse ) + DELETEZ(pReader); + + // alle DirEntries aus der Liste entfernen und deren Speicher freigeben + if ( pLst ) + { + DirEntry* pEntry = pLst->First(); + while (pEntry) + { + DirEntry* pNext = pLst->Next(); + delete pEntry; + pEntry = pNext; + } + pLst->Clear(); + } + else + pLst = new DirEntryList(); + + // Alte File-Stat's Loeschen + if ( pStatLst ) + { + //Erstmal die alten Loeschen + FileStat* pEntry = pStatLst->First(); + while (pEntry) + { + FileStat* pNext = pStatLst->Next(); + delete pEntry; + pEntry = pNext; + } + pStatLst->Clear(); + delete pStatLst; + } + + // Verlangen die Sortierkriterien FileStat's? + if ( pSortLst ) + { + pSortLst->First(); + do + { + if ( *( pSortLst->GetCurObject() ) & + ( FSYS_SORT_KIND | FSYS_SORT_SIZE | + FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_ACCESSED ) ) + pStatLst = new FileStatList(); + } while ( !pStatLst && pSortLst->Next() ); + } + +#ifndef BOOTSTRAP + // ggf. einen neuen Reader aufsetzen + if ( !pReader ) + pReader = new DirReader_Impl( *this ); +#endif + + // gibt es das zu oeffnende Verzeichnis ueberhaupt? +#ifndef UNX //explanation: see DirReader_Impl::Read() in unx.cxx + if( !pReader->pDosDir ) + { + nError = FSYS_ERR_NOTADIRECTORY; + DELETEZ( pReader ); + return; + } +#endif +} + +/************************************************************************* +|* +|* Dir::Scan() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 18.09.96 +|* Letzte Aenderung MI 19.09.96 +|* +*************************************************************************/ + +USHORT Dir::Scan( USHORT nCount ) +{ + + USHORT nRead = 0; // Anzahl in dieser Runde gelesener Eintr"age + FSysFailOnErrorImpl(); + + // noch nicht fertig gewesen + if ( pReader ) + { + // frischer Reader? + if ( !pLst->Count() ) + { + // dann ggf. Laufwerke scannen + pReader->bInUse = TRUE; + nRead = pReader->Init(); + } + + // weiterlesen... + while ( nRead <= nCount && !pReader->bReady ) + nRead += pReader->Read(); + + // fertig? + if ( pReader && pReader->bReady ) + DELETEZ( pReader ); + } + + // Anzahl der gelesenen zur"uckgeben + return nRead; +} + +/************************************************************************* +|* +|* Dir::Dir() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MI 04.03.92 +|* +*************************************************************************/ + +Dir::Dir( const DirEntry& rDirEntry, DirEntryKind nKindFlags, FSysSort nSort, ... ): + DirEntry( rDirEntry ), + pReader( 0 ) +{ + DBG_CTOR( Dir, NULL ); + + Construct( nKindFlags ); + + va_list pArgs; + va_start( pArgs, nSort ); + ImpSetSort( pArgs, nSort ); + + Reset(); +} + +/************************************************************************* +|* +|* Dir::Dir() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 02.06.93 +|* Letzte Aenderung MI 02.06.93 +|* +*************************************************************************/ + +Dir::Dir( const DirEntry& rDirEntry, DirEntryKind nKindFlags ): + DirEntry( rDirEntry ), + pReader( 0 ) +{ + DBG_CTOR( Dir, NULL ); + + Construct( nKindFlags ); + Reset(); +} + +/************************************************************************* +|* +|* Dir::Dir() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MA 04.11.91 +|* +*************************************************************************/ + +Dir::Dir(): + pReader( 0 ) +{ + DBG_CTOR( Dir, NULL ); + + pLst = NULL; + pSortLst = NULL; + pStatLst = NULL; + eAttrMask = FSYS_KIND_ALL; + aNameMask = String("*", osl_getThreadTextEncoding()); +} + +/************************************************************************* +|* +|* Dir::~Dir() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MA 04.11.91 +|* +*************************************************************************/ + +Dir::~Dir() +{ + DBG_DTOR( Dir, NULL ); + + // alle DirEntries aus der Liste entfernen und deren Speicher freigeben + if ( pLst ) + { + DirEntry* pEntry = pLst->First(); + while (pEntry) + { + DirEntry* pNext = pLst->Next(); + delete pEntry; + pEntry = pNext; + } + pLst->Clear(); + + delete pLst; + } + + // alle Sorts aus der Liste entfernen und deren Speicher freigeben + if ( pSortLst ) + { + FSysSort* pEntry = pSortLst->First(); + while (pEntry) + { + FSysSort* pNext = pSortLst->Next(); + delete pEntry; + pEntry = pNext; + } + pSortLst->Clear(); + + delete pSortLst; + } + + // alle FileStat's aus der Liste entfernen und deren Speicher freigeben + if ( pStatLst ) + { + FileStat* pEntry = pStatLst->First(); + while (pEntry) + { + FileStat* pNext = pStatLst->Next(); + delete pEntry; + pEntry = pNext; + } + pStatLst->Clear(); + delete pStatLst; + } + + // ggf. laufenden Reader freigeben + delete pReader; +} + +/************************************************************************* +|* +|* Dir::ImpSetSort() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 04.11.91 +|* Letzte Aenderung MI 05.02.92 +|* +*************************************************************************/ + +FSysError Dir::ImpSetSort( va_list pArgs, int nFirstSort ) +{ + BOOL bLast; + FSysSort *pSort; + FSysSortList *pNewSortLst = new FSysSortList; + + *( pSort = new FSysSort ) = nFirstSort; + do + { + // letztes Kriterium? + bLast = FSYS_SORT_END == (*pSort & FSYS_SORT_END); + *pSort &= ~FSYS_SORT_END; + + // Ascending oder Descending? + BOOL bAscending = FSYS_SORT_ASCENDING == + ( *pSort & ( FSYS_SORT_ASCENDING | FSYS_SORT_DESCENDING ) ); + USHORT nSort = *pSort & ~(USHORT)FSYS_SORT_ASCENDING + & ~(USHORT)FSYS_SORT_DESCENDING; + + // g"utliges Sortierkriterium? + if ( ( nSort == FSYS_SORT_NAME ) || + ( nSort == FSYS_SORT_SIZE ) || + ( nSort == FSYS_SORT_EXT ) || + ( nSort == FSYS_SORT_CREATED ) || + ( nSort == FSYS_SORT_MODIFYED ) || + ( nSort == FSYS_SORT_ACCESSED ) || + ( nSort == FSYS_SORT_KIND ) ) + { + pNewSortLst->Insert( pSort, APPEND ); + *(pSort = new FSysSort) = va_arg( pArgs, FSysSort ); + } + else + { // ungueltiger Sort oder FSYS_SORT_NONE + FSysSort* pEntry = pNewSortLst->First(); + while (pEntry) + { + FSysSort* pNext = pNewSortLst->Next(); + delete pEntry; + pEntry = pNext; + } + pNewSortLst->Clear(); + delete pNewSortLst; + if ( *pSort == FSYS_SORT_NONE ) + { + delete pSort; + if ( pSortLst ) + delete pSortLst; + return FSYS_ERR_OK; + } + else + { + delete pSort; + return FSYS_ERR_NOTSUPPORTED; + } + } + } while ( !bLast ); + + va_end( pArgs ); + delete pSort; // JP:6.3.00 - delete the initial pointer + + //Enfernen der alten Sort-Elemente + if ( pSortLst ) + { + FSysSort* pEntry = pSortLst->First(); + while (pEntry) + { + FSysSort* pNext = pSortLst->Next(); + delete pEntry; + pEntry = pNext; + } + pSortLst->Clear(); + delete pSortLst; + } + pSortLst = pNewSortLst; + + //Jetzt noch neu Sortieren... + + //Wenn keine FileStats da sind, aber nun welche gebraucht werden, + //ist der Aufruf von Update() die einfachste Moeglichkeit + if ( !pStatLst && pSortLst ) + { + pSortLst->First(); + do + { + if ( *(pSortLst->GetCurObject()) & + ( FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_SIZE | + FSYS_SORT_ACCESSED | FSYS_SORT_KIND ) ) + { + Update(); + return FSYS_ERR_OK; + } + } while ( !pStatLst && pSortLst->Next() ); + } + + if ( pLst ) { //Keine DirEntry's, kein Sort. + DirEntryList *pOldLst = pLst; //alte Liste merken + pLst = new DirEntryList(); //neue Liste (zu Sortieren) + + FileStatList *pOldStatLst = NULL; //alte StatListe merken + if ( pStatLst ) { + pOldStatLst = pStatLst; + pStatLst = new FileStatList(); //neue StatListe (zu Sortieren) + } + pOldLst->First(); + do + { + //Sortiertes Einfuegen der Elemente aus den gemerkten Listen + //in die 'richtigen' Listen + if ( pOldStatLst ) + ImpSortedInsert( pOldLst->GetCurObject(), + pOldStatLst->GetObject( pOldLst->GetCurPos() ) ); + else + ImpSortedInsert( pOldLst->GetCurObject(), NULL ); + } while( pOldLst->Next() ); + + delete pOldLst; + if ( pOldStatLst ) + delete pOldStatLst; + } + return FSYS_ERR_OK; +} + +/************************************************************************* +|* +|* Dir::SetSort() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 04.11.91 +|* Letzte Aenderung MI 05.02.92 +|* +*************************************************************************/ + +FSysError Dir::SetSort( FSysSort nSort, ... ) +{ + va_list pArgs; + va_start( pArgs, nSort ); + return ImpSetSort( pArgs, nSort ); +} + +/************************************************************************* +|* +|* Dir::operator[]() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MI 16.05.91 +|* +*************************************************************************/ + +DirEntry& Dir::operator[] ( USHORT nIndex ) const +{ + DBG_ASSERT( nIndex < Count(), "Dir::operator[] : nIndex > Count()" ); + + DirEntry *pEntry = pLst->GetObject( nIndex ); + return *pEntry; +} + +/************************************************************************* +|* +|* Dir::operator+= () +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MI 16.05.91 +|* +*************************************************************************/ + +Dir& Dir::operator+=( const Dir& rDir ) +{ + // ggf. erst den Rest lesen + if ( pReader ) + Scan( USHRT_MAX ); + DBG_ASSERT( !rDir.pReader, "Dir::+= with incomplete Dir" ); + + // ggf. initiale Liste erzeugen + if ( !pLst ) + pLst = new DirEntryList(); + + //Verlangen die Sortierkriterien FileStat's? + BOOL bStat = FALSE; + if ( pSortLst ) { + pSortLst->First(); + do { + if ( *(pSortLst->GetCurObject()) & + ( FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_SIZE | + FSYS_SORT_ACCESSED | FSYS_SORT_KIND ) ) + bStat = TRUE; + } while ( !bStat && pSortLst->Next() ); + } + FileStat *pStat = NULL; + for ( USHORT nNr = 0; nNr < rDir.Count(); nNr++ ) { + if ( bStat ) + if ( rDir.pStatLst ) + { + pStat = new FileStat( *rDir.pStatLst->GetObject(nNr) ); + } + else + pStat = new FileStat( rDir[nNr] ); + ImpSortedInsert( new DirEntry( rDir[nNr] ), pStat ); + } + return *this; +} + +/************************************************************************* +|* +|* Dir::Count() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 16.05.91 +|* Letzte Aenderung MI 18.09.96 +|* +*************************************************************************/ + + +USHORT Dir::Count( BOOL bUpdated ) const +{ + // ggf. erst den Rest lesen + if ( bUpdated && pReader ) + ((Dir*)this)->Scan( USHRT_MAX ); + + return pLst == NULL ? 0 : (USHORT) pLst->Count(); +} diff --git a/tools/source/fsys/tempfile.cxx b/tools/source/fsys/tempfile.cxx new file mode 100644 index 000000000000..f920d18dde0f --- /dev/null +++ b/tools/source/fsys/tempfile.cxx @@ -0,0 +1,337 @@ +/************************************************************************* + * + * $RCSfile: tempfile.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include "tempfile.hxx" +#include "comdep.hxx" + +#include <rtl/ustring.hxx> +#ifndef _OSL_FILE_HXX_ +#include <osl/file.hxx> +#endif +#ifndef _TOOLS_TIME_HXX +#include <time.hxx> +#endif +#include <debug.hxx> +#include <stdio.h> + +#ifdef UNX +#define _MAX_PATH 260 +#endif + +using namespace osl; + +static ::rtl::OUString aTempNameBase_Impl; + +struct TempFile_Impl +{ + String aName; + sal_Bool bIsDirectory; +}; + +String GetSystemTempDir_Impl() +{ + char sBuf[_MAX_PATH]; + const char *pDir = TempDirImpl(sBuf); + ::rtl::OUString aTmp = ::rtl::OUString::createFromAscii( pDir ); + rtl::OUString aRet; + FileBase::normalizePath( aTmp, aRet ); + String aName = aRet; + sal_Int32 i = aName.Len(); + if( aName.GetChar(i-1) != '/' ) + aName += '/'; + return aName; +} + +#define TMPNAME_SIZE ( 1 + 5 + 5 + 4 + 1 ) +String ConstructTempDir_Impl( const String* pParent ) +{ + String aName; + if ( pParent && pParent->Len() ) + { + // if parent given try to use it + rtl::OUString aTmp( *pParent ); + rtl::OUString aRet; + + // test for valid filename + if ( FileBase::getNormalizedPathFromFileURL( aTmp, aRet ) == FileBase::E_None ) + { + ::osl::DirectoryItem aItem; + sal_Int32 i = aRet.getLength(); + if ( aRet[i-1] == '/' ) + i--; + + if ( DirectoryItem::get( ::rtl::OUString( aRet, i ), aItem ) == FileBase::E_None ) + aName = aRet; + } + } + + if ( !aName.Len() ) + { + // if no parent or invalid parent : use system directory + if ( !aTempNameBase_Impl.getLength() ) + aTempNameBase_Impl = GetSystemTempDir_Impl(); + aName = aTempNameBase_Impl; + } + + // Make sure that directory ends with a separator + sal_Int32 i = aName.Len(); + if( i>0 && aName.GetChar(i-1) != '/' ) + aName += '/'; + + return aName; +} + +void CreateTempName_Impl( String& rName, sal_Bool bKeep, sal_Bool bDir = sal_True ) +{ + // add a suitable tempname + // Prefix can have 5 chars, leaving 3 for numbers. 26 ** 3 == 17576 + // ER 13.07.00 why not radix 36 [0-9A-Z] ?!? + const unsigned nRadix = 26; + String aName( rName ); + aName += String::CreateFromAscii( "sv" ); + sal_Int32 i = aName.Len(); + + rName.Erase(); + static unsigned long u = Time::GetSystemTicks(); + for ( unsigned long nOld = u; ++u != nOld; ) + { + u %= (nRadix*nRadix*nRadix); + String aTmp( aName ); + aTmp += String::CreateFromInt32( (sal_Int32) (unsigned) u, nRadix ); + aTmp += String::CreateFromAscii( ".tmp" ); + + if ( bDir ) + { + FileBase::RC err = Directory::create( aTmp ); + if ( err == FileBase::E_None ) + { + // !bKeep: only for creating a name, not a file or directory + if ( bKeep || Directory::remove( aTmp ) == FileBase::E_None ) + rName = aTmp; + break; + } + else if ( err != FileBase::E_EXIST ) + { + // if f.e. name contains invalid chars stop trying to create dirs + break; + } + } + else + { + DBG_ASSERT( bKeep, "Too expensive, use directory for creating name!" ); + File aFile( aTmp ); + FileBase::RC err = aFile.open(osl_File_OpenFlag_Create); + if ( err == FileBase::E_None ) + { + rName = aTmp; + aFile.close(); + break; + } + else if ( err != FileBase::E_EXIST ) + { + // if f.e. name contains invalid chars stop trying to create files + break; + } + } + } +} + +String TempFile::CreateTempName( const String* pParent ) +{ + // get correct directory + String aName = ConstructTempDir_Impl( pParent ); + + // get TempFile name with default naming scheme + CreateTempName_Impl( aName, sal_False ); + + // convert to file URL + rtl::OUString aTmp; + if ( aName.Len() ) + FileBase::getFileURLFromNormalizedPath( aName, aTmp ); + return aTmp; +} + +TempFile::TempFile( const String* pParent, sal_Bool bDirectory ) + : pImp( new TempFile_Impl ) + , bKillingFileEnabled( sal_False ) +{ + pImp->bIsDirectory = bDirectory; + + // get correct directory + pImp->aName = ConstructTempDir_Impl( pParent ); + + // get TempFile with default naming scheme + CreateTempName_Impl( pImp->aName, sal_True, bDirectory ); +} + +TempFile::TempFile( const String& rLeadingChars, const String* pExtension, const String* pParent, sal_Bool bDirectory ) + : pImp( new TempFile_Impl ) + , bKillingFileEnabled( sal_False ) +{ + pImp->bIsDirectory = bDirectory; + + // get correct directory + String aName = ConstructTempDir_Impl( pParent ); + + // now use special naming scheme ( name takes leading chars and an index counting up from zero + aName += rLeadingChars; + for ( sal_Int32 i=0;; i++ ) + { + String aTmp( aName ); + aTmp += String::CreateFromInt32( i ); + if ( pExtension ) + aTmp += *pExtension; + else + aTmp += String::CreateFromAscii( ".tmp" ); + if ( bDirectory ) + { + FileBase::RC err = Directory::create( aTmp ); + if ( err == FileBase::E_None ) + { + pImp->aName = aTmp; + break; + } + else if ( err != FileBase::E_EXIST ) + // if f.e. name contains invalid chars stop trying to create dirs + break; + } + else + { + File aFile( aTmp ); + FileBase::RC err = aFile.open(osl_File_OpenFlag_Create); + if ( err == FileBase::E_None ) + { + pImp->aName = aTmp; + aFile.close(); + break; + } + else if ( err != FileBase::E_EXIST ) + // if f.e. name contains invalid chars stop trying to create dirs + break; + } + } +} + +TempFile::~TempFile() +{ + if ( bKillingFileEnabled ) + { + if ( pImp->bIsDirectory ) + { + // at the moment no recursiv algorithm present + Directory::remove( pImp->aName ); + } + else + { + File::remove( pImp->aName ); + } + } + + delete pImp; +} + +sal_Bool TempFile::IsValid() const +{ + return pImp->aName.Len() != 0; +} + +String TempFile::GetName() const +{ + rtl::OUString aTmp; + FileBase::getFileURLFromNormalizedPath( pImp->aName, aTmp ); + return aTmp; +} + +String TempFile::SetTempNameBaseDirectory( const String &rBaseName ) +{ +// if ( !aTempNameBase_Impl.getLength() ) +// aTempNameBase_Impl = GetSystemTempDir_Impl(); +// String aName( aTempNameBase_Impl ); +// aName += rBaseName; + + String aName( rBaseName ); + + FileBase::RC err= Directory::create( aName ); + if ( err == FileBase::E_None || err == FileBase::E_EXIST ) + { + aTempNameBase_Impl = aName; + aTempNameBase_Impl += ::rtl::OUString( '/' ); + + TempFile aBase( NULL, sal_True ); + if ( aBase.IsValid() ) + aTempNameBase_Impl = aBase.pImp->aName; + } + + rtl::OUString aTmp; + FileBase::getFileURLFromNormalizedPath( aTempNameBase_Impl, aTmp ); + return aTmp; +} + +String TempFile::GetTempNameBaseDirectory() +{ + if ( !aTempNameBase_Impl.getLength() ) + aTempNameBase_Impl = GetSystemTempDir_Impl(); + + rtl::OUString aTmp; + FileBase::getFileURLFromNormalizedPath( aTempNameBase_Impl, aTmp ); + return aTmp; +} + diff --git a/tools/source/fsys/unx.cxx b/tools/source/fsys/unx.cxx new file mode 100644 index 000000000000..245ba9ebad4d --- /dev/null +++ b/tools/source/fsys/unx.cxx @@ -0,0 +1,694 @@ +/************************************************************************* + * + * $RCSfile: unx.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdio.h> +#include <ctype.h> +#include <stdlib.h> +#include <unistd.h> +#include <utime.h> +#if defined HPUX || defined LINUX || defined IRIX +#include <mntent.h> +#define mnttab mntent +#elif defined SCO +#include <mnttab.h> +#elif defined AIX +#include <sys/mntctl.h> +#include <sys/vmount.h> +extern "C" int mntctl( int cmd, size_t size, char* buf ); +#elif defined S390 +#include <sys/mntent.h> +#define mnttab w_mntent +#elif defined(NETBSD) || defined(FREEBSD) || defined(MACOSX) +#elif defined DECUNIX +struct mnttab +{ + char *mnt_dir; + char *mnt_fsname; +}; +#else +#include <sys/mnttab.h> +#endif + +#ifndef MAXPATHLEN +#define MAXPATHLEN 1024 +#endif + +#include <debug.hxx> +#include <list.hxx> +#include <fsys.hxx> +#include "comdep.hxx" + +DECLARE_LIST( DirEntryList, DirEntry* ) +DECLARE_LIST( FSysSortList, FSysSort* ) +DECLARE_LIST( FileStatList, FileStat* ) + +#if defined SOLARIS || defined SINIX +#define MOUNTSPECIAL mnt_special +#define MOUNTPOINT mnt_mountp +#define MOUNTOPTS mnt_mntopts +#define MOUNTFS mnt_fstype +#elif defined SCO +#define MNTTAB "/etc/mnttab" +#define MOUNTSPECIAL mt_dev +#define MOUNTPOINT mt_filsys +#elif defined S390 +#define MOUNTSPECIAL mnt_fsname +#define MOUNTPOINT mnt_mountpoint +#else +#define MOUNTSPECIAL mnt_fsname +#define MOUNTPOINT mnt_dir +#define MOUNTFS mnt_type +#endif + +static ByteString sLastCaseSensitiveDir = ""; +static BOOL bLastCaseSensitive = FALSE; + +struct mymnttab +{ + dev_t mountdevice; + ByteString mountspecial; + ByteString mountpoint; + ByteString mymnttab_filesystem; + mymnttab() { mountdevice = (dev_t) -1; } +}; + + +#if defined(NETBSD) || defined(FREEBSD) || defined(MACOSX) +BOOL GetMountEntry(dev_t dev, struct mymnttab *mytab) +{ + DBG_WARNING( "Sorry, not implemented: GetMountEntry" ); + return FALSE; +} + +#elif defined AIX +BOOL GetMountEntry(dev_t dev, struct mymnttab *mytab) +{ + int bufsize; + if (mntctl (MCTL_QUERY, sizeof bufsize, (char*) &bufsize)) + return FALSE; + + char* buffer = (char *)malloc( bufsize * sizeof(char) ); + if (mntctl (MCTL_QUERY, bufsize, buffer) != -1) + for ( char* vmt = buffer; + vmt < buffer + bufsize; + vmt += ((struct vmount*)vmt)->vmt_length) + { + struct stat buf; + char *mountp = vmt2dataptr((struct vmount*)vmt, VMT_STUB); + if ((stat (mountp, &buf) != -1) && (buf.st_dev == dev)) + { + mytab->mountpoint = mountp; + mytab->mountspecial + = vmt2dataptr((struct vmount*)vmt, VMT_HOSTNAME); + if (mytab->mountspecial.Len()) + mytab->mountspecial += ':'; + mytab->mountspecial + += vmt2dataptr((struct vmount*)vmt, VMT_OBJECT); + mytab->mountdevice = dev; + free( buffer ); + return TRUE; + } + } + free( buffer ); + return FALSE; +} + +#else + + +static BOOL GetMountEntry(dev_t dev, struct mymnttab *mytab) +{ +#if defined SOLARIS || defined SINIX + FILE *fp = fopen (MNTTAB, "r"); + if (! fp) + return FALSE; + struct mnttab mnt[1]; + while (getmntent (fp, mnt) != -1) +#elif defined SCO + FILE *fp = fopen (MNTTAB, "r"); + if (! fp) + return FALSE; + struct mnttab mnt[1]; + while (fread (&mnt, sizeof mnt, 1, fp) > 0) +#elif defined DECUNIX || defined AIX || defined S390 + FILE *fp = NULL; + if (! fp) + return FALSE; + struct mnttab mnt[1]; + while ( 0 ) +#else + FILE *fp = setmntent (MOUNTED, "r"); + if (! fp) + return FALSE; + struct mnttab *mnt; + while ((mnt = getmntent (fp)) != NULL) +#endif + { +#ifdef SOLARIS + char *devopt = NULL; + if ( mnt->MOUNTOPTS != NULL ) + devopt = strstr (mnt->MOUNTOPTS, "dev="); + if (devopt) + { + if (dev != (dev_t) strtoul (devopt+4, NULL, 16)) + continue; + } + else +#endif + { + struct stat buf; + if ((stat (mnt->MOUNTPOINT, &buf) == -1) || (buf.st_dev != dev)) + continue; + } +# ifdef LINUX + /* #61624# File mit setmntent oeffnen und mit fclose schliessen stoesst + bei der glibc-2.1 auf wenig Gegenliebe */ + endmntent( fp ); +# else + fclose (fp); +# endif + mytab->mountspecial = mnt->MOUNTSPECIAL; + mytab->mountpoint = mnt->MOUNTPOINT; + mytab->mountdevice = dev; +#ifndef SCO + mytab->mymnttab_filesystem = mnt->MOUNTFS; +#else + mytab->mymnttab_filesystem = "ext2"; //default ist case sensitiv unter unix +#endif + return TRUE; + } +# ifdef LINUX + /* #61624# dito */ + endmntent( fp ); +# else + fclose (fp); +# endif + return FALSE; +} + +#endif + +/************************************************************************ +|* +|* DirEntry::IsCaseSensitive() +|* +|* Beschreibung +|* Ersterstellung TPF 25.02.1999 +|* Letzte Aenderung TPF 25.02.1999 +|* +*************************************************************************/ + +BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const +{ + + if (eFormatter==FSYS_STYLE_HOST) + { +#ifdef NETBSD + return TRUE; +#else + struct stat buf; + DirEntry aPath(*this); + aPath.ToAbs(); + + while (stat (ByteString(aPath.GetFull(), osl_getThreadTextEncoding()).GetBuffer(), &buf)) + { + if (aPath.Level() == 1) + { + return TRUE; // ich bin unter UNIX, also ist der default im Zweifelsfall case sensitiv + } + aPath = aPath [1]; + } + + struct mymnttab fsmnt; + GetMountEntry(buf.st_dev, &fsmnt); + if ((fsmnt.mymnttab_filesystem.CompareTo("msdos")==COMPARE_EQUAL) || + (fsmnt.mymnttab_filesystem.CompareTo("umsdos")==COMPARE_EQUAL) || + (fsmnt.mymnttab_filesystem.CompareTo("vfat")==COMPARE_EQUAL) || + (fsmnt.mymnttab_filesystem.CompareTo("hpfs")==COMPARE_EQUAL) || + (fsmnt.mymnttab_filesystem.CompareTo("smb") ==COMPARE_EQUAL) || + (fsmnt.mymnttab_filesystem.CompareTo("ncpfs")==COMPARE_EQUAL)) + { + return FALSE; + } + else + { + return TRUE; + } +#endif + } + else + { + BOOL isCaseSensitive = TRUE; // ich bin unter UNIX, also ist der default im Zweifelsfall case sensitiv + switch ( eFormatter ) + { + case FSYS_STYLE_MAC: + case FSYS_STYLE_FAT: + case FSYS_STYLE_VFAT: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + case FSYS_STYLE_HPFS: + { + isCaseSensitive = FALSE; + break; + } + case FSYS_STYLE_SYSV: + case FSYS_STYLE_BSD: + case FSYS_STYLE_DETECT: + { + isCaseSensitive = TRUE; + break; + } + default: + { + isCaseSensitive = TRUE; // ich bin unter UNIX, also ist der default im Zweifelsfall case sensitiv + break; + } + } + return isCaseSensitive; + } +} + +/************************************************************************ +|* +|* DirEntry::ToAbs() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 13:30 +|* +*************************************************************************/ + +BOOL DirEntry::ToAbs() +{ + if ( FSYS_FLAG_VOLUME == eFlag ) + { + eFlag = FSYS_FLAG_ABSROOT; + return TRUE; + } + + if ( IsAbs() ) + return TRUE; + + char sBuf[MAXPATHLEN + 1]; + *this = DirEntry( String( getcwd( sBuf, MAXPATHLEN ), osl_getThreadTextEncoding() ) ) + *this; + return IsAbs(); +} + +/************************************************************************* +|* +|* DirEntry::GetVolume() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 04.03.92 +|* Letzte Aenderung +|* +*************************************************************************/ + +static mymnttab mymnt; +static String aEmptyString; + +String DirEntry::GetVolume() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aPath( *this ); + aPath.ToAbs(); + + struct stat buf; + while (stat (ByteString(aPath.GetFull(), osl_getThreadTextEncoding()).GetBuffer(), &buf)) + { + if (aPath.Level() <= 1) + return aEmptyString; + aPath = aPath [1]; + } + + return ((buf.st_dev == mymnt.mountdevice || + GetMountEntry(buf.st_dev, &mymnt)) ? String(mymnt.mountspecial, osl_getThreadTextEncoding()) : aEmptyString); +} + +DirEntry DirEntry::GetDevice() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + DirEntry aPath( *this ); + aPath.ToAbs(); + + struct stat buf; + while (stat (ByteString(aPath.GetFull(), osl_getThreadTextEncoding()).GetBuffer(), &buf)) + { + if (aPath.Level() <= 1) + return aEmptyString; + aPath = aPath [1]; + } + return ((buf.st_dev == mymnt.mountdevice || + GetMountEntry(buf.st_dev, &mymnt)) ? String( mymnt.mountpoint, osl_getThreadTextEncoding()) : aEmptyString); +} + +/************************************************************************* +|* +|* DirEntry::SetCWD() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung DV 04.11.92 +|* +*************************************************************************/ + +BOOL DirEntry::SetCWD( BOOL bSloppy ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + + ByteString aPath( GetFull(), osl_getThreadTextEncoding()); + if ( !chdir( aPath.GetBuffer() ) ) + { + return TRUE; + } + else + { + if ( bSloppy && !chdir(aPath.GetBuffer()) ) + { + return TRUE; + } + else + { + return FALSE; + } + } +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Init() +{ + return 0; +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Read() +{ + if (!pDosDir) + { + pDosDir = opendir( (char*) ByteString(aPath, osl_getThreadTextEncoding()).GetBuffer() ); + } + + if (!pDosDir) + { + bReady = TRUE; + return 0; + } + + // Directories und Files auflisten? + if ( ( pDir->eAttrMask & FSYS_KIND_DIR || pDir->eAttrMask & FSYS_KIND_FILE ) && + ( ( pDosEntry = readdir( pDosDir ) ) != NULL ) ) + { + String aD_Name(pDosEntry->d_name, osl_getThreadTextEncoding()); + if ( pDir->aNameMask.Matches( aD_Name ) ) + { + DirEntryFlag eFlag = + 0 == strcmp( pDosEntry->d_name, "." ) ? FSYS_FLAG_CURRENT + : 0 == strcmp( pDosEntry->d_name, ".." ) ? FSYS_FLAG_PARENT + : FSYS_FLAG_NORMAL; + DirEntry *pTemp = new DirEntry( ByteString(pDosEntry->d_name), eFlag, FSYS_STYLE_UNX ); + if ( pParent ) + pTemp->ImpChangeParent( new DirEntry( *pParent ), FALSE); + FileStat aStat( *pTemp ); + if ( ( ( ( pDir->eAttrMask & FSYS_KIND_DIR ) && + ( aStat.IsKind( FSYS_KIND_DIR ) ) ) || + ( ( pDir->eAttrMask & FSYS_KIND_FILE ) && + !( aStat.IsKind( FSYS_KIND_DIR ) ) ) ) && + !( pDir->eAttrMask & FSYS_KIND_VISIBLE && + pDosEntry->d_name[0] == '.' ) ) + { + if ( pDir->pStatLst ) //Status fuer Sort gewuenscht? + pDir->ImpSortedInsert( pTemp, new FileStat( aStat ) ); + else + pDir->ImpSortedInsert( pTemp, NULL );; + return 1; + } + else + delete pTemp; + } + } + else + bReady = TRUE; + return 0; +} + +/************************************************************************* +|* +|* FileStat::FileStat() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MA 05.11.91 +|* Letzte Aenderung MA 07.11.91 +|* +*************************************************************************/ + +FileStat::FileStat( const void *, const void * ): + aDateCreated(0), + aTimeCreated(0), + aDateModified(0), + aTimeModified(0), + aDateAccessed(0), + aTimeAccessed(0) +{ +} + +/************************************************************************* +|* +|* FileStat::Update() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 11.06.91 +|* Letzte Aenderung MA 07.11.91 +|* +*************************************************************************/ +#if SUPD < 345 +BOOL FileStat::Update( const DirEntry& rDirEntry ) +{ + return Update( rDirEntry, FALSE ); +} +#endif + +BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bAccessRemovableDevice ) +{ + + nSize = 0; + nKindFlags = 0; + aCreator.Erase(); + aType.Erase(); + aDateCreated = Date(0); + aTimeCreated = Time(0); + aDateModified = Date(0); + aTimeModified = Time(0); + aDateAccessed = Date(0); + aTimeAccessed = Time(0); + + if ( !rDirEntry.IsValid() ) + { + nError = FSYS_ERR_NOTEXISTS; + return FALSE; + } + + // Sonderbehandlung falls es sich um eine Root handelt + if ( rDirEntry.eFlag == FSYS_FLAG_ABSROOT ) + { + nKindFlags = FSYS_KIND_DIR; + nError = FSYS_ERR_OK; + return TRUE; + } + + struct stat aStat; + ByteString aPath( rDirEntry.GetFull(), osl_getThreadTextEncoding() ); + if ( stat( (char*) aPath.GetBuffer(), &aStat ) ) + { + // pl: #67851# + // do this here, because an existing filename containing "wildcards" + // should be handled as a file, not a wildcard + // note that this is not a solution, since filenames containing special characters + // are handled badly across the whole Office + + // Sonderbehandlung falls es sich um eine Wildcard handelt + ByteString aTempName( rDirEntry.GetName(), osl_getThreadTextEncoding() ); + if ( strchr( (char*) aTempName.GetBuffer(), '?' ) || + strchr( (char*) aTempName.GetBuffer(), '*' ) || + strchr( (char*) aTempName.GetBuffer(), ';' ) ) + { + nKindFlags = FSYS_KIND_WILD; + nError = FSYS_ERR_OK; + return TRUE; + } + + nError = FSYS_ERR_NOTEXISTS; + return FALSE; + } + + nError = FSYS_ERR_OK; + nSize = aStat.st_size; + + nKindFlags = FSYS_KIND_UNKNOWN; + if ( ( aStat.st_mode & S_IFDIR ) == S_IFDIR ) + nKindFlags = nKindFlags | FSYS_KIND_DIR; + if ( ( aStat.st_mode & S_IFREG ) == S_IFREG ) + nKindFlags = nKindFlags | FSYS_KIND_FILE; + if ( ( aStat.st_mode & S_IFCHR ) == S_IFCHR ) + nKindFlags = nKindFlags | FSYS_KIND_DEV | FSYS_KIND_CHAR; + if ( ( aStat.st_mode & S_IFBLK ) == S_IFBLK ) + nKindFlags = nKindFlags | FSYS_KIND_DEV | FSYS_KIND_BLOCK; + if ( nKindFlags == FSYS_KIND_UNKNOWN ) + nKindFlags = nKindFlags | FSYS_KIND_FILE; + + Unx2DateAndTime( aStat.st_ctime, aTimeCreated, aDateCreated ); + Unx2DateAndTime( aStat.st_mtime, aTimeModified, aDateModified ); + Unx2DateAndTime( aStat.st_atime, aTimeAccessed, aDateAccessed ); + + return TRUE; +} + +//==================================================================== + +const char *TempDirImpl( char *pBuf ) +{ + const char *pValue = getenv( "TEMP" ); + if ( !pValue ) + pValue = getenv( "TMP" ); + if ( pValue ) + strcpy( pBuf, pValue ); + else + // auf Solaris und Linux ist P_tmpdir vorgesehen + strcpy( pBuf, P_tmpdir ); + // hart auf "/tmp" sollte wohl nur im Notfall verwendet werden + //strcpy( pBuf, "/tmp" ); + return pBuf; +} + +/************************************************************************* +|* +|* DirEntry::GetPathStyle() const +|* +|* Beschreibung +|* Ersterstellung MI 11.05.95 +|* Letzte Aenderung MI 11.05.95 +|* +*************************************************************************/ + +FSysPathStyle DirEntry::GetPathStyle( const String &rDevice ) +{ + return FSYS_STYLE_UNX; +} + +/************************************************************************* +|* +|* FileStat::SetDateTime +|* +|* Ersterstellung PB 27.06.97 +|* Letzte Aenderung +|* +*************************************************************************/ + +void FileStat::SetDateTime( const String& rFileName, + const DateTime& rNewDateTime ) +{ + tm times; + + times.tm_year = rNewDateTime.GetYear() - 1900; // 1997 -> 97 + times.tm_mon = rNewDateTime.GetMonth() - 1; // 0 == Januar! + times.tm_mday = rNewDateTime.GetDay(); + + times.tm_hour = rNewDateTime.GetHour(); + times.tm_min = rNewDateTime.GetMin(); + times.tm_sec = rNewDateTime.GetSec(); + + times.tm_wday = 0; + times.tm_yday = 0; +#ifdef SOLARIS + times.tm_isdst = -1; +#else + times.tm_isdst = 0; +#endif + + time_t time = mktime (×); + + if (time != (time_t) -1) + { + struct utimbuf u_time; + u_time.actime = time; + u_time.modtime = time; + utime (ByteString(rFileName, osl_getThreadTextEncoding()).GetBuffer(), &u_time); + } +} + +//========================================================================= + +ErrCode FileStat::QueryDiskSpace( const String &rPath, + BigInt &rFreeBytes, BigInt &rTotalBytes ) +{ + return ERRCODE_IO_NOTSUPPORTED; +} + +//========================================================================= + +void FSysEnableSysErrorBox( BOOL bEnable ) +{ +} + diff --git a/tools/source/fsys/unx.hxx b/tools/source/fsys/unx.hxx new file mode 100644 index 000000000000..2751289b7c2e --- /dev/null +++ b/tools/source/fsys/unx.hxx @@ -0,0 +1,139 @@ +/************************************************************************* + * + * $RCSfile: unx.hxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _unx_hxx +#define _unx_hxx + +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> + +#ifndef S390 +#include <sys/param.h> +#endif + +#include <dirent.h> +#include <unistd.h> +/* #include <sysent.h> */ + +#define FSYS_UNIX TRUE +#define DRIVE_EXISTS(c) ( TRUE ) + +#define _mkdir(p) mkdir(p, 0777) +#define _rmdir rmdir +#define _chdir chdir +#define _unlink unlink +#define _getcwd getcwd +#define _access access + +#ifdef SYSV3 +#define DEFSTYLE FSYS_STYLE_SYSV +#else +#define DEFSTYLE FSYS_STYLE_BSD +#endif + +#define CMP_LOWER(s) (s) +#define TEMPNAME() tmpnam(0) +#define LOWER(aString) (aString.Lower()) + +#include <time.h> +#include <datetime.hxx> + +#ifndef localtime_r +extern "C" { +struct tm *localtime_r(const time_t *timep, struct tm *buffer); +} +#endif + +inline Time Unx2Time( time_t nTime ) +{ + tm atm; + tm *pTime; + pTime = localtime_r( &nTime, &atm ); + return Time( pTime->tm_hour, + pTime->tm_min, + pTime->tm_sec ); +} + +inline Date Unx2Date( time_t nDate ) +{ + tm atm; + tm *pTime; + pTime = localtime_r( &nDate, &atm ); + return Date( pTime->tm_mday, + pTime->tm_mon + 1, + pTime->tm_year + 1900 ); +} + +inline void Unx2DateAndTime( time_t nDate, Time& rTime, Date& rDate ) +{ + tm atm; + tm *pTime; + pTime = localtime_r( &nDate, &atm ); + rTime = Time( pTime->tm_hour, pTime->tm_min, pTime->tm_sec ); + rDate = Date( pTime->tm_mday, pTime->tm_mon + 1, pTime->tm_year + 1900 ); +} + +const char* TempDirImpl( char *pBuf ); + +#define FSysFailOnErrorImpl() + +#endif diff --git a/tools/source/fsys/urlobj.cxx b/tools/source/fsys/urlobj.cxx new file mode 100644 index 000000000000..e3c937c5a7d4 --- /dev/null +++ b/tools/source/fsys/urlobj.cxx @@ -0,0 +1,5021 @@ +/************************************************************************* + * + * $RCSfile: urlobj.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define min min // fool <tools/solar.h>... +#define max max // fool <tools/solar.h>... + +#ifndef _URLOBJ_HXX +#include <urlobj.hxx> +#endif + +#include <limits> + +#ifndef _OSL_FILE_HXX_ +#include <osl/file.hxx> +#endif + +#ifndef _TOOLS_DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef TOOLS_INETMIME_HXX +#include <inetmime.hxx> +#endif +#ifndef _TOOLS_INTN_HXX +#include <intn.hxx> +#endif + +namespace unnamed_tools_urlobj {} using namespace unnamed_tools_urlobj; + // unnamed namespaces don't work well yet... + +//============================================================================ +// +// INetURLObject +// +//============================================================================ + +/* The URI grammar (using RFC 2234 conventions). + + Constructs of the form + {reference <rule1> using rule2} + stand for a rule matching the given rule1 specified in the given reference, + encoded to URI syntax using rule2 (as specified in this URI grammar). + + + ; RFC 1738, RFC 2396, RFC 2732, private + login = [user [":" password] "@"] hostport + user = *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ";" / "=" / "_" / "~") + password = *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ";" / "=" / "_" / "~") + hostport = host [":" port] + host = incomplete-hostname / hostname / IPv4address / IPv6reference + incomplete-hostname = *(domainlabel ".") domainlabel + hostname = *(domainlabel ".") toplabel ["."] + domainlabel = alphadigit [*(alphadigit / "-") alphadigit] + toplabel = ALPHA [*(alphadigit / "-") alphadigit] + alphadigit = ALPHA / DIGIT + IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT + IPv6reference = "[" hexpart [":" IPv4address] "]" + hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) + hexseq = hex4 *(":" hex4) + hex4 = 1*4HEXDIG + port = *DIGIT + escaped = "%" HEXDIG HEXDIG + reserved = "$" / "&" / "+" / "," / "/" / ":" / ";" / "=" / "?" / "@" / "[" / "]" + mark = "!" / "'" / "(" / ")" / "*" / "-" / "." / "_" / "~" + alphanum = ALPHA / DIGIT + unreserved = alphanum / mark + uric = escaped / reserved / unreserved + pchar = escaped / unreserved / "$" / "&" / "+" / "," / ":" / "=" / "@" + + + ; RFC 1738, RFC 2396 + ftp-url = "FTP://" login ["/" segment *("/" segment) [";TYPE=" ("A" / "D" / "I")]] + segment = *pchar + + + ; RFC 1738, RFC 2396 + http-url = "HTTP://" hostport ["/" segment *("/" segment) ["?" *uric]] + segment = *(pchar / ";") + + + ; RFC 1738, RFC 2396 + file-url = "FILE://" [host / "LOCALHOST"] ["/" segment *("/" segment)] + segment = *pchar + + + ; RFC 2368, RFC 2396 + mailto-url = "MAILTO:" [to] [headers] + to = {RFC 822 <#mailbox> using *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} + headers = "?" header *("&" header) + header = hname "=" hvalue + hname = {RFC 822 <field-name> using *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} / "BODY" + hvalue = {RFC 822 <field-body> using *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} + + + ; private (see RFC 1738) + news-url = "NEWS://" login ["/" (group / message)] + group = *uric + message = "<" *uric ">" + + + ; private + private-url = "PRIVATE:" path ["?" *uric] + path = *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~" + + + ; private + https-url = "HTTPS://" hostport ["/" segment *("/" segment) ["?" *uric]] + segment = *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "@" / "_" / "~") + + + ; private + slot-url = "SLOT:" path ["?" *uric] + path = *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~" + + + ; private + macro-url = "MACRO:" path ["?" *uric] + path = *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~" + + + ; private + javascript-url = "JAVASCRIPT:" *uric + + + ; private (see RFC 2192) + imap-url = "IMAP://" user [";AUTH=" auth] "@" hostport "/" segment *("/" segment) ["/;UID=" nz_number] + user = 1*{RFC 2060 <CHAR8> using (escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "=" / "_" / "~")} + auth = {RFC 2060 <atom> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "+" / "," / "-" / "." / "=" / "_" / "~")} + segment = *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / "=" / "@" / "_" / "~") + nz_number = {RFC 2060 <nz_number> using *DIGIT} + + + ; private + pop3-url = "POP3://" login ["/" ["<" *uric ">"]] + + + ; RFC 2397 + data-url = "DATA:" [mediatype] [";BASE64"] "," *uric + mediatype = [type "/" subtype] *(";" attribute "=" value) + type = {RFC 2045 <type> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} + subtype = {RFC 2045 <subtype> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} + attribute = {RFC 2045 <subtype> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} + value = {RFC 2045 <subtype> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / ":" / "?" / "@" / "_" / "~")} + + + ; RFC 2392, RFC 2396 + cid-url = "CID:" {RFC 822 <addr-spec> using *uric} + + + ; private + out-url = "OUT:///~" name ["/" *uric] + name = *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / ":" / ";" / "=" / "?" / "@" / "_" / "~" + + + ; private + vim-url = "VIM://" +vimc [":" *vimc] ["/" [("INBOX" message) / ("NEWSGROUPS" ["/" [+vimc message]])]] + message = ["/" [+vimc [":" +DIGIT "." +DIGIT "." +DIGIT]]] + vimc = ("=" HEXDIG HEXDIG) / ALPHA / DIGIT + + + ; private + uno-url = ".UNO:" *uric + + + ; private + component-url = ".COMPONENT:" path ["?" *uric] + path = *(escaped / ALPHA / DIGIT / "!" / "$" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~" + + + ; RFC 2255 + ldap-url = "LDAP://" [hostport] ["/" [dn ["?" [attrdesct *("," attrdesc)] ["?" ["base" / "one" / "sub"] ["?" [filter] ["?" extension *("," extension)]]]]]] + dn = {RFC 2253 <distinguishedName> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} + attrdesc = {RFC 2251 <AttributeDescription> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} + filter = {RFC 2254 <filter> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} + extension = ["!"] ["X-"] extoken ["=" exvalue] + extoken = {RFC 2252 <oid> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "@" / "_" / "~")} + exvalue = {RFC 2251 <LDAPString> using *(escaped / ALPHA / DIGIT / "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "-" / "." / "/" / ":" / ";" / "=" / "@" / "_" / "~")} + + + ; private + db-url = "DB:" *uric + */ + +//============================================================================ +inline sal_Int32 INetURLObject::SubString::clear() +{ + sal_Int32 nDelta = -m_nLength; + m_nBegin = STRING_NOTFOUND; + m_nLength = 0; + return nDelta; +} + +//============================================================================ +inline sal_Int32 INetURLObject::SubString::set(UniString & rString, + UniString const & rSubString) +{ + DBG_ASSERT(isPresent(), "INetURLObject::SubString::set(): Not present"); + sal_Int32 nDelta = rSubString.Len() - m_nLength; + rString.Replace(m_nBegin, m_nLength, rSubString); + m_nLength = rSubString.Len(); + return nDelta; +} + +//============================================================================ +inline sal_Int32 INetURLObject::SubString::set(UniString & rString, + UniString const & rSubString, + xub_StrLen nTheBegin) +{ + m_nBegin = nTheBegin; + return set(rString, rSubString); +} + +//============================================================================ +inline void INetURLObject::SubString::operator +=(sal_Int32 nDelta) +{ + if (isPresent()) + m_nBegin += nDelta; +} + +//============================================================================ +bool INetURLObject::SubString::equals(SubString const & rOther, + UniString const & rThisString, + UniString const & rOtherString) const +{ + if (m_nLength != rOther.m_nLength) + return true; + sal_Unicode const * p1 = rThisString.GetBuffer() + m_nBegin; + sal_Unicode const * p1End = p1 + m_nLength; + sal_Unicode const * p2 = rOtherString.GetBuffer() + rOther.m_nBegin; + while (p1 != p1End) + if (*p1++ != *p2++) + return false; + return true; +} + +//============================================================================ +struct INetURLObject::SchemeInfo +{ + sal_Char const * m_pScheme; + sal_Char const * m_pPrefix; + sal_uInt16 m_nDefaultPort; + bool m_bAuthority; + bool m_bUser; + bool m_bAuth; + bool m_bPassword; + bool m_bHost; + bool m_bPort; + bool m_bHierarchical; + bool m_bQuery; +}; + +//============================================================================ +struct INetURLObject::PrefixInfo +{ + enum Kind { OFFICIAL, EXTERNAL, INTERNAL }; + + sal_Char const * m_pPrefix; + sal_Char const * m_pTranslatedPrefix; + INetProtocol m_eScheme; + Kind m_eKind; +}; + +//============================================================================ +// static + +static INetURLObject::SchemeInfo const aSchemeInfoMap[INET_PROT_END] + = { { "", "", 0, false, false, false, false, false, false, false, + false }, + { "ftp", "ftp://", 21, true, true, false, true, true, true, true, + false }, + { "http", "http://", 80, true, false, false, false, true, true, + true, true }, + { "file", "file://", 0, true, false, false, false, true, false, + true, false }, + { "mailto", "mailto:", 0, false, false, false, false, false, + false, false, true }, + { 0, 0, 0, false, false, false, false, false, false, false, + false }, + { "news", "news:", 119, true, true, false, true, true, true, + false, false }, + { "private", "private:", 0, false, false, false, false, false, + false, false, true }, + { 0, 0, 0, false, false, false, false, false, false, false, + false }, + { "https", "https://", 443, true, false, false, false, true, true, + true, true }, + { "slot", "slot:", 0, false, false, false, false, false, false, + false, true }, + { "macro", "macro:", 0, false, false, false, false, false, false, + false, true }, + { "javascript", "javascript:", 0, false, false, false, false, + false, false, false, false }, + { "imap", "imap://", 143, true, true, true, false, true, true, + true, false }, + { "pop3", "pop3://", 110, true, true, false, true, true, true, + false, false }, + { "data", "data:", 0, false, false, false, false, false, false, + false, false }, + { "cid", "cid:", 0, false, false, false, false, false, false, + false, false }, + { "out", "out://", 0, true, false, false, false, false, false, + false, false }, + { 0, 0, 0, false, false, false, false, false, false, false, + false }, + { 0, 0, 0, false, false, false, false, false, false, false, + false }, + { "vim", "vim://", 0, true, true, false, true, false, false, true, + false }, + { ".uno", ".uno:", 0, false, false, false, false, false, false, + false, false }, + { ".component", ".component:", 0, false, false, false, false, + false, false, false, true }, + { 0, 0, 0, false, false, false, false, false, false, false, + false }, + { "ldap", "ldap://", 389, true, false, false, false, true, true, + false, true }, + { "db", "db:", 0, false, false, false, false, false, false, false, + false }, + { 0, 0, 0, false, false, false, false, false, false, false, + false } }; + +inline INetURLObject::SchemeInfo const & +INetURLObject::getSchemeInfo(INetProtocol eTheScheme) +{ + return aSchemeInfoMap[eTheScheme]; +}; + +//============================================================================ +inline INetURLObject::SchemeInfo const & INetURLObject::getSchemeInfo() const +{ + return getSchemeInfo(m_eScheme); +} + +//============================================================================ +// static +inline void INetURLObject::appendEscape(UniString & rTheText, + sal_Char cEscapePrefix, + sal_uInt32 nOctet) +{ + rTheText += cEscapePrefix; + rTheText += sal_Unicode(INetMIME::getHexDigit(int(nOctet >> 4))); + rTheText += sal_Unicode(INetMIME::getHexDigit(int(nOctet & 15))); +} + +//============================================================================ +// static +inline void INetURLObject::appendUTF32(UniString & rTheText, + sal_uInt32 nUTF32) +{ + DBG_ASSERT(nUTF32 <= 0x10FFFF, "INetURLObject::appendUTF32(): Bad char"); + if (nUTF32 < 0x10000) + rTheText += sal_Unicode(nUTF32); + else + { + nUTF32 -= 0x10000; + rTheText += sal_Unicode(0xD800 | nUTF32 >> 10); + rTheText += sal_Unicode(0xDC00 | nUTF32 & 0x3FF); + } +} + +//============================================================================ +namespace unnamed_tools_urlobj { + +enum +{ + pA = INetURLObject::PART_OBSOLETE_NORMAL, + pB = INetURLObject::PART_OBSOLETE_FILE, + pC = INetURLObject::PART_OBSOLETE_PARAM, + pD = INetURLObject::PART_USER_PASSWORD, + pE = INetURLObject::PART_IMAP_ACHAR, + pF = INetURLObject::PART_VIM, + pG = INetURLObject::PART_HOST_EXTRA, + pH = INetURLObject::PART_FPATH, + pI = INetURLObject::PART_AUTHORITY, + pJ = INetURLObject::PART_PATH_SEGMENTS_EXTRA, + pK = INetURLObject::PART_REL_SEGMENT_EXTRA, + pL = INetURLObject::PART_URIC, + pM = INetURLObject::PART_HTTP_PATH, + pN = INetURLObject::PART_FILE_SEGMENT_EXTRA, + pO = INetURLObject::PART_MESSAGE_ID, + pP = INetURLObject::PART_MESSAGE_ID_PATH, + pQ = INetURLObject::PART_MAILTO, + pR = INetURLObject::PART_PATH_BEFORE_QUERY, + pS = INetURLObject::PART_PCHAR, + pT = INetURLObject::PART_FRAGMENT, + pU = INetURLObject::PART_VISIBLE, + pV = INetURLObject::PART_VISIBLE_NONSPECIAL, + pW = INetURLObject::PART_CREATEFRAGMENT, + pX = INetURLObject::PART_UNO_PARAM_VALUE, + pY = INetURLObject::PART_UNAMBIGUOUS +}; +static sal_uInt32 const aMustEncodeMap[128] + = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* */ pY, +/* ! */ pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* " */ pU+pV+pY, +/* # */ pU, +/* $ */ pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* % */ pU, +/* & */ pA+pB+pC+pD+pE+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pR+pS+pT+pU+pV+pW+pX, +/* ' */ pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* ( */ pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* ) */ pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* * */ pA+pB+pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* + */ pA+pB+pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX, +/* , */ pA+pB+pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW, +/* - */ pA+pB+pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* . */ pA+pB+pC+pD+pE+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* / */ pA+pB+pC+pH+pJ+pL+pM+pP+pQ+pR+pT+pU+pV+pX, +/* 0 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 1 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 2 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 3 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 4 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 5 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 6 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 7 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 8 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* 9 */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* : */ pB+pC+pH+pI+pJ+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX, +/* ; */ pC+pD+pI+pJ+pK+pL+pM+pO+pP+pQ+pR+pT+pU+pW, +/* < */ pC+pO+pP+pU+pV+pY, +/* = */ pA+pB+pC+pD+pE+pH+pI+pJ+pK+pL+pM+pN+pR+pS+pT+pU+pV+pW, +/* > */ pC+pO+pP+pU+pV+pY, +/* ? */ pC+pL+pT+pU+pW+pX, +/* @ */ pC+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* A */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* B */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* C */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* D */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* E */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* F */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* G */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* H */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* I */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* J */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* K */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* L */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* M */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* N */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* O */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* P */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* Q */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* R */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* S */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* T */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* U */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* V */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* W */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* X */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* Y */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* Z */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* [ */ pL+pU+pV+pX, +/* \ */ pB+pU+pV+pY, +/* ] */ pL+pU+pV+pX, +/* ^ */ pU+pV+pY, +/* _ */ pA+pB+pC+pD+pE +pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* ` */ +pU+pV+pY, +/* a */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* b */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* c */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* d */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* e */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* f */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* g */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* h */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* i */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* j */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* k */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* l */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* m */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* n */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* o */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* p */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* q */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* r */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* s */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* t */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* u */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* v */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* w */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* x */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* y */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* z */ pA+pB+pC+pD+pE+pF+pG+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* { */ +pU+pV+pY, +/* | */ pB+pC+pN+pT+pU+pV+pY, +/* } */ +pU+pV+pY, +/* ~ */ pA+pB+pC+pD+pE+pH+pI+pJ+pK+pL+pM+pN+pO+pP+pQ+pR+pS+pT+pU+pV+pW+pX+pY, +/* */ 0 }; + +inline bool mustEncode(sal_uInt32 nUTF32, INetURLObject::Part ePart) +{ + return !INetMIME::isUSASCII(nUTF32) || !(aMustEncodeMap[nUTF32] & ePart); +} + +} + +//============================================================================ +void INetURLObject::setInvalid() +{ + m_aAbsURIRef.Erase(); + m_eScheme = INET_PROT_NOT_VALID; + m_aUser.clear(); + m_aAuth.clear(); + m_aHost.clear(); + m_aPort.clear(); + m_aPath.clear(); + m_aQuery.clear(); + m_aFragment.clear(); +} + +//============================================================================ + +namespace unnamed_tools_urlobj { + +INetURLObject::FSysStyle +guessFSysStyleByCounting(sal_Unicode const * pBegin, + sal_Unicode const * pEnd, + INetURLObject::FSysStyle eStyle) +{ + DBG_ASSERT(eStyle + & (INetURLObject::FSYS_UNX + | INetURLObject::FSYS_DOS + | INetURLObject::FSYS_MAC), + "guessFSysStyleByCounting(): Bad style"); + DBG_ASSERT(std::numeric_limits< sal_Int32 >::min() < pBegin - pEnd + && pEnd - pBegin <= std::numeric_limits< sal_Int32 >::max(), + "guessFSysStyleByCounting(): Too big"); + sal_Int32 nSlashCount + = eStyle & INetURLObject::FSYS_UNX ? + 0 : std::numeric_limits< sal_Int32 >::min(); + sal_Int32 nBackslashCount + = eStyle & INetURLObject::FSYS_DOS ? + 0 : std::numeric_limits< sal_Int32 >::min(); + sal_Int32 nColonCount + = eStyle & INetURLObject::FSYS_MAC ? + 0 : std::numeric_limits< sal_Int32 >::min(); + while (pBegin != pEnd) + switch (*pBegin++) + { + case '/': + ++nSlashCount; + break; + + case '\\': + ++nBackslashCount; + break; + + case ':': + ++nColonCount; + break; + } + return nSlashCount >= nBackslashCount ? + nSlashCount >= nColonCount ? + INetURLObject::FSYS_UNX : INetURLObject::FSYS_MAC : + nBackslashCount >= nColonCount ? + INetURLObject::FSYS_DOS : INetURLObject::FSYS_MAC; +} + +} + +bool INetURLObject::setAbsURIRef(UniString const & rTheAbsURIRef, + bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + bool bSmart, + FSysStyle eStyle) +{ + sal_Unicode const * pPos = rTheAbsURIRef.GetBuffer(); + sal_Unicode const * pEnd = pPos + rTheAbsURIRef.Len(); + + setInvalid(); + + sal_uInt32 nFragmentDelimiter = '#'; + + UniString aSynAbsURIRef; + + // Parse <scheme>: + sal_Unicode const * p = pPos; + PrefixInfo const * pPrefix = getPrefix(p, pEnd); + if (pPrefix) + { + pPos = p; + m_eScheme = pPrefix->m_eScheme; + aSynAbsURIRef + = UniString::CreateFromAscii(pPrefix->m_eKind + == PrefixInfo::EXTERNAL ? + pPrefix->m_pTranslatedPrefix : + pPrefix->m_pPrefix); + } + else + { + if (bSmart) + { + // For scheme detection, the first (if any) of the following + // productions that matches the input string (and for which the + // appropriate style bit is set in eStyle, if applicable) + // determines the scheme. The productions use the auxiliary rules + // + // domain = label *("." label) + // label = alphanum [*(alphanum / "-") alphanum] + // alphanum = ALPHA / DIGIT + // IPv6reference = "[" IPv6address "]" + // IPv6address = hexpart [":" IPv4address] + // IPv4address = 1*3DIGIT 3("." 1*3DIGIT) + // hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) + // hexseq = hex4 *(":" hex4) + // hex4 = 1*4HEXDIG + // UCS4 = <any UCS4 character> + // + // 1st Production (known scheme): + // <one of the known schemes, ignoring case> ":" *UCS4 + // + // 2nd Production (mailto): + // domain "@" domain + // + // 3rd Production (ftp): + // "ftp" 2*("." label) ["/" *UCS4] + // + // 4th Production (http): + // label 2*("." label) ["/" *UCS4] + // + // 5th Production (file): + // "//" (domain / IPv6reference) ["/" *UCS4] + // + // 6th Production (Unix file): + // "/" *UCS4 + // + // 7th Production (UNC file; FSYS_DOS only): + // "\\" domain ["\" *UCS4] + // + // 8th Production (Unix-like DOS file; FSYS_DOS only): + // ALPHA ":/" *UCS4 + // + // 9th Production (DOS file; FSYS_DOS only): + // ALPHA ":\" *UCS4 + // + // For the 'non URL' file productions 6--9, the interpretation of + // the input as a (degenerate) URI is turned off, i.e., escape + // sequences and fragments are never detected as such, but are + // taken as literal characters. + + sal_Unicode const * p = pPos; + if (eStyle & FSYS_DOS + && pEnd - p >= 3 + && INetMIME::isAlpha(p[0]) + && p[1] == ':' + && (p[2] == '/' || p[2] == '\\')) + { + m_eScheme = INET_PROT_FILE; // 8th, 9th + eMechanism = ENCODE_ALL; + nFragmentDelimiter = 0x80000000; + } + else if (pEnd - p >= 2 && p[0] == '/' && p[1] == '/') + { + p += 2; + if ((scanDomain(p, pEnd) > 0 || scanIPv6reference(p, pEnd)) + && (p == pEnd || *p == '/')) + m_eScheme = INET_PROT_FILE; // 5th + } + else if (p != pEnd && *p == '/') + { + m_eScheme = INET_PROT_FILE; // 6th + eMechanism = ENCODE_ALL; + nFragmentDelimiter = 0x80000000; + } + else if (eStyle & FSYS_DOS + && pEnd - p >= 2 + && p[0] == '\\' + && p[1] == '\\') + { + p += 2; + if (scanDomain(p, pEnd) > 0 && (p == pEnd || *p == '\\')) + { + m_eScheme = INET_PROT_FILE; // 7th + eMechanism = ENCODE_ALL; + nFragmentDelimiter = 0x80000000; + } + } + else + { + sal_Unicode const * pDomainEnd = p; + sal_uInt32 nLabels = scanDomain(pDomainEnd, pEnd); + if (nLabels > 0 && pDomainEnd != pEnd && *pDomainEnd == '@') + { + ++pDomainEnd; + if (scanDomain(pDomainEnd, pEnd) > 0 + && pDomainEnd == pEnd) + m_eScheme = INET_PROT_MAILTO; // 2nd + } + else if (nLabels >= 3 + && (pDomainEnd == pEnd || *pDomainEnd == '/')) + m_eScheme + = pDomainEnd - p >= 4 + && p[0] == 'f' + && p[1] == 't' + && p[2] == 'p' + && p[3] == '.' ? + INET_PROT_FTP : INET_PROT_HTTP; // 3rd, 4th + } + + if (m_eScheme == INET_PROT_NOT_VALID && pPos != pEnd + && *pPos != nFragmentDelimiter) + m_eScheme = m_eSmartScheme; + } + + if (m_eScheme == INET_PROT_NOT_VALID) + { + setInvalid(); + return false; + } + + aSynAbsURIRef = UniString::CreateFromAscii(getSchemeInfo().m_pScheme); + aSynAbsURIRef += ':'; + } + + sal_Char cEscapePrefix = getEscapePrefix(); + sal_uInt32 nSegmentDelimiter = '/'; + sal_uInt32 nAltSegmentDelimiter = 0x80000000; + bool bSkippedInitialSlash = false; + + // Parse //<user>;AUTH=<auth>@<host>:<port> or + // //<user>:<password>@<host>:<port> + if (getSchemeInfo().m_bAuthority) + { + aSynAbsURIRef.AppendAscii(RTL_CONSTASCII_STRINGPARAM("//")); + + sal_Unicode const * pUserInfoBegin = 0; + sal_Unicode const * pUserInfoEnd = 0; + sal_Unicode const * pHostPortBegin = 0; + sal_Unicode const * pHostPortEnd = 0; + + switch (m_eScheme) + { + case INET_PROT_FILE: + if (bSmart) + { + // The first of the following seven productions that + // matches the rest of the input string (and for which the + // appropriate style bit is set in eStyle, if applicable) + // determines the used notation. The productions use the + // auxiliary rules + // + // domain = label *("." label) + // label = alphanum [*(alphanum / "-") alphanum] + // alphanum = ALPHA / DIGIT + // IPv6reference = "[" IPv6address "]" + // IPv6address = hexpart [":" IPv4address] + // IPv4address = 1*3DIGIT 3("." 1*3DIGIT) + // hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) + // hexseq = hex4 *(":" hex4) + // hex4 = 1*4HEXDIG + // path = <any UCS4 character except "#"> + // UCS4 = <any UCS4 character> + + // 1st Production (URL): + // "//" [domain / IPv6reference] ["/" *path] + // ["#" *UCS4] + // becomes + // "file://" domain "/" *path ["#" *UCS4] + if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') + { + sal_Unicode const * p = pPos + 2; + if (p == pEnd || *p == nFragmentDelimiter || *p == '/' + || (scanDomain(p, pEnd) > 0 + || scanIPv6reference(p, pEnd)) + && (p == pEnd || *p == nFragmentDelimiter + || *p == '/')) + { + pHostPortBegin = pPos + 2; + pHostPortEnd = p; + pPos = p; + break; + } + } + + // 2nd Production (misscounted slashes): + // "//" *path ["#" *UCS4] + // becomes + // "file:///" *path ["#" *UCS4] + if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') + { + pPos += 2; + bSkippedInitialSlash = true; + break; + } + + // 3rd Production (Unix): + // "/" *path ["#" *UCS4] + // becomes + // "file:///" *path ["#" *UCS4] + if (pPos < pEnd && *pPos == '/') + break; + + // 4th Production (UNC; FSYS_DOS only): + // "\\" domain ["\" *path] ["#" *UCS4] + // becomes + // "file://" domain "/" *path ["#" *UCS4] + // replacing "\" by "/" within <*path> + if (eStyle & FSYS_DOS + && pEnd - pPos >= 2 + && pPos[0] == '\\' + && pPos[1] == '\\') + { + sal_Unicode const * p = pPos + 2; + if (scanDomain(p, pEnd) > 0 + && (p == pEnd || *p == nFragmentDelimiter + || *p == '\\')) + { + pHostPortBegin = pPos + 2; + pHostPortEnd = p; + pPos = p; + nSegmentDelimiter = '\\'; + break; + } + } + + // 5th Production (Unix-like DOS; FSYS_DOS only): + // ALPHA ":/" *path ["#" *UCS4] + // becomes + // "file:///" ALPHA ":/" *path ["#" *UCS4] + // replacing "\" by "/" within <*path> + // + // 6th Production (DOS; FSYS_DOS only): + // ALPHA ":\" *path ["#" *UCS4] + // becomes + // "file:///" ALPHA ":/" *path ["#" *UCS4] + // replacing "\" by "/" within <*path> + if (eStyle & FSYS_DOS + && pEnd - pPos >= 3 + && INetMIME::isAlpha(pPos[0]) + && pPos[1] == ':' + && (pPos[2] == '/' || pPos[2] == '\\')) + { + nAltSegmentDelimiter = '\\'; + bSkippedInitialSlash = true; + break; + } + + // 7th Production (any): + // *path ["#" *UCS4] + // becomes + // "file:///" *path ["#" *UCS4] + // replacing the delimiter by "/" within <*path>. The + // delimiter is that character from the set { "/", "\", + // ":" } which appears most often in <*path> (if FSYS_UNX + // is not among the style bits, "/" is removed from the + // set; if FSYS_DOS is not among the style bits, "\" is + // removed from the set; if FSYS_MAC is not among the + // style bits, ":" is removed from the set). If two or + // more characters appear the same number of times, the + // character mentioned first in that set is chosen. If + // the first character of <*path> is the delimiter, that + // character is not copied. + if (eStyle & (FSYS_UNX | FSYS_DOS | FSYS_MAC)) + { + switch (guessFSysStyleByCounting(pPos, pEnd, eStyle)) + { + case FSYS_UNX: + nSegmentDelimiter = '/'; + break; + + case FSYS_DOS: + nSegmentDelimiter = '\\'; + break; + + case FSYS_MAC: + nSegmentDelimiter = ':'; + break; + + default: + DBG_ERROR( + "INetURLObject::setAbsURIRef():" + " Bad guessFSysStyleByCounting"); + break; + } + bSkippedInitialSlash + = pPos != pEnd && *pPos != nSegmentDelimiter; + break; + } + } + default: + { + if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/') + pPos += 2; + else if (!bSmart) + { + setInvalid(); + return false; + } + + sal_Unicode const * pAuthority = pPos; + sal_uInt32 c = getSchemeInfo().m_bQuery ? '?' : 0x80000000; + while (pPos < pEnd && *pPos != '/' && *pPos != c + && *pPos != nFragmentDelimiter) + ++pPos; + if (getSchemeInfo().m_bUser) + if (getSchemeInfo().m_bHost) + { + sal_Unicode const * p = pAuthority; + while (p < pPos && *p != '@') + ++p; + if (p == pPos) + { + pHostPortBegin = pAuthority; + pHostPortEnd = pPos; + } + else + { + pUserInfoBegin = pAuthority; + pUserInfoEnd = p; + pHostPortBegin = p + 1; + pHostPortEnd = pPos; + } + } + else + { + pUserInfoBegin = pAuthority; + pUserInfoEnd = pPos; + } + else if (getSchemeInfo().m_bHost) + { + pHostPortBegin = pAuthority; + pHostPortEnd = pPos; + } + else if (pPos != pAuthority) + { + setInvalid(); + return false; + } + break; + } + } + + if (pUserInfoBegin) + { + Part ePart = m_eScheme == INET_PROT_IMAP ? + PART_IMAP_ACHAR : + m_eScheme == INET_PROT_VIM ? + PART_VIM : + PART_USER_PASSWORD; + bool bSupportsPassword = getSchemeInfo().m_bPassword; + bool bSupportsAuth + = !bSupportsPassword && getSchemeInfo().m_bAuth; + bool bHasAuth = false; + UniString aSynUser; + sal_Unicode const * p = pUserInfoBegin; + while (p < pUserInfoEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(p, pUserInfoEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + if (eEscapeType == ESCAPE_NO) + if (nUTF32 == ':' && bSupportsPassword) + { + bHasAuth = true; + break; + } + else if (nUTF32 == ';' && bSupportsAuth + && pUserInfoEnd - p + > RTL_CONSTASCII_LENGTH("auth=") + && INetMIME::equalIgnoreCase( + p, + p + RTL_CONSTASCII_LENGTH("auth="), + "auth=")) + { + p += RTL_CONSTASCII_LENGTH("auth="); + bHasAuth = true; + break; + } + appendUCS4(aSynUser, nUTF32, eEscapeType, bOctets, ePart, + cEscapePrefix, eCharset, false); + } + m_aUser.set(aSynAbsURIRef, aSynUser, aSynAbsURIRef.Len()); + if (bHasAuth) + if (bSupportsPassword) + { + aSynAbsURIRef += ':'; + UniString aSynAuth; + while (p < pUserInfoEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(p, pUserInfoEnd, bOctets, + cEscapePrefix, + eMechanism, eCharset, + eEscapeType); + appendUCS4(aSynAuth, nUTF32, eEscapeType, bOctets, + ePart, cEscapePrefix, eCharset, false); + } + m_aAuth.set(aSynAbsURIRef, aSynAuth, aSynAbsURIRef.Len()); + } + else + { + aSynAbsURIRef. + AppendAscii(RTL_CONSTASCII_STRINGPARAM(";AUTH=")); + UniString aSynAuth; + while (p < pUserInfoEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(p, pUserInfoEnd, bOctets, + cEscapePrefix, + eMechanism, eCharset, + eEscapeType); + if (!INetMIME::isIMAPAtomChar(nUTF32)) + { + setInvalid(); + return false; + } + appendUCS4(aSynAuth, nUTF32, eEscapeType, bOctets, + ePart, cEscapePrefix, eCharset, false); + } + m_aAuth.set(aSynAbsURIRef, aSynAuth, aSynAbsURIRef.Len()); + } + if (pHostPortBegin) + aSynAbsURIRef += '@'; + } + + if (pHostPortBegin) + { + sal_Unicode const * pPort = pHostPortEnd; + if (getSchemeInfo().m_bPort && pHostPortBegin < pHostPortEnd) + { + sal_Unicode const * p = pHostPortEnd - 1; + while (p > pHostPortBegin && INetMIME::isDigit(*p)) + --p; + if (*p == ':') + pPort = p; + } + switch (m_eScheme) + { + case INET_PROT_FILE: + // If the host equals "LOCALHOST" (unencoded and ignoring + // case), turn it into an empty host: + if (INetMIME::equalIgnoreCase(pHostPortBegin, pPort, + "localhost")) + pHostPortBegin = pPort; + break; + + case INET_PROT_LDAP: + if (pHostPortBegin == pPort && pPort != pHostPortEnd) + { + setInvalid(); + return false; + } + break; + + default: + if (pHostPortBegin == pPort) + { + setInvalid(); + return false; + } + break; + } + UniString aSynHost; + if (pHostPortBegin != pPort + && (!parseHost(pHostPortBegin, pPort, bOctets, eMechanism, + eCharset, aSynHost) + || pHostPortBegin != pPort)) + { + setInvalid(); + return false; + } + m_aHost.set(aSynAbsURIRef, aSynHost, aSynAbsURIRef.Len()); + if (pPort != pHostPortEnd) + { + aSynAbsURIRef += ':'; + m_aPort.set(aSynAbsURIRef, + UniString(pPort + 1, pHostPortEnd - (pPort + 1)), + aSynAbsURIRef.Len()); + } + } + } + + // Parse <path> + UniString aSynPath; + if (!parsePath(&pPos, pEnd, bOctets, eMechanism, eCharset, + bSkippedInitialSlash, nSegmentDelimiter, + nAltSegmentDelimiter, + getSchemeInfo().m_bQuery ? '?' : 0x80000000, + nFragmentDelimiter, &aSynPath)) + { + setInvalid(); + return false; + } + m_aPath.set(aSynAbsURIRef, aSynPath, aSynAbsURIRef.Len()); + + // Parse ?<query> + if (getSchemeInfo().m_bQuery && pPos < pEnd && *pPos == '?') + { + aSynAbsURIRef += '?'; + UniString aSynQuery; + for (++pPos; pPos < pEnd && *pPos != nFragmentDelimiter;) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, + eMechanism, eCharset, eEscapeType); + appendUCS4(aSynQuery, nUTF32, eEscapeType, bOctets, + PART_URIC, cEscapePrefix, eCharset, true); + } + m_aQuery.set(aSynAbsURIRef, aSynQuery, aSynAbsURIRef.Len()); + } + + // Parse #<fragment> + if (pPos < pEnd && *pPos == nFragmentDelimiter) + { + aSynAbsURIRef += nFragmentDelimiter; + UniString aSynFragment; + for (++pPos; pPos < pEnd;) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, cEscapePrefix, + eMechanism, eCharset, eEscapeType); + appendUCS4(aSynFragment, nUTF32, eEscapeType, bOctets, PART_URIC, + cEscapePrefix, eCharset, true); + } + m_aFragment.set(aSynAbsURIRef, aSynFragment, aSynAbsURIRef.Len()); + } + + if (pPos != pEnd) + { + setInvalid(); + return false; + } + + m_aAbsURIRef = aSynAbsURIRef; + + return true; +} + +//============================================================================ +// static +INetURLObject INetURLObject::m_aBaseURIRef; + +//============================================================================ +bool INetURLObject::convertRelToAbs(UniString const & rTheRelURIRef, + bool bOctets, + INetURLObject & rTheAbsURIRef, + bool & rWasAbsolute, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + bool bIgnoreFragment, bool bSmart, + bool bRelativeNonURIs, FSysStyle eStyle) + const +{ + sal_Unicode const * p = rTheRelURIRef.GetBuffer(); + sal_Unicode const * pEnd = p + rTheRelURIRef.Len(); + + sal_Unicode const * pPrefixBegin = p; + PrefixInfo const * pPrefix = getPrefix(pPrefixBegin, pEnd); + + sal_uInt32 nSegmentDelimiter = '/'; + sal_uInt32 nQueryDelimiter + = !bSmart || getSchemeInfo().m_bQuery ? '?' : 0x80000000; + sal_uInt32 nFragmentDelimiter = '#'; + Part ePart = PART_VISIBLE; + + if (!pPrefix && bSmart) + { + // If the input matches any of the following productions (for which + // the appropriate style bit is set in eStyle), it is assumed to be an + // absolute file system path, rather than a relative URI reference. + // (This is only a subset of the productions used for scheme detection + // in INetURLObject::setAbsURIRef(), because most of those productions + // interfere with the syntax of relative URI references.) The + // productions use the auxiliary rules + // + // domain = label *("." label) + // label = alphanum [*(alphanum / "-") alphanum] + // alphanum = ALPHA / DIGIT + // UCS4 = <any UCS4 character> + // + // 1st Production (UNC file; FSYS_DOS only): + // "\\" domain ["\" *UCS4] + // + // 2nd Production (Unix-like DOS file; FSYS_DOS only): + // ALPHA ":/" *UCS4 + // + // 3rd Production (DOS file; FSYS_DOS only): + // ALPHA ":\" *UCS4 + if (eStyle & FSYS_DOS) + { + bool bFSys = false; + sal_Unicode const * q = p; + if (pEnd - q >= 3 + && INetMIME::isAlpha(q[0]) + && q[1] == ':' + && (q[2] == '/' || q[2] == '\\')) + bFSys = true; // 2nd, 3rd + else if (pEnd - q >= 2 && q[0] == '\\' && q[1] == '\\') + { + q += 2; + if (scanDomain(q, pEnd) > 0 && (q == pEnd || *q == '\\')) + bFSys = true; // 1st + } + if (bFSys) + { + INetURLObject aNewURI; + aNewURI.setAbsURIRef(rTheRelURIRef, bOctets, eMechanism, + eCharset, true, eStyle); + if (!aNewURI.HasError()) + { + rTheAbsURIRef = aNewURI; + rWasAbsolute = true; + return true; + } + } + } + + // When the base URL is a file URL, accept relative file system paths + // using "\" or ":" as delimiter (and ignoring URI conventions for "%" + // and "#"), as well as relative URIs using "/" as delimiter: + if (m_eScheme == INET_PROT_FILE) + switch (guessFSysStyleByCounting(p, pEnd, eStyle)) + { + case FSYS_UNX: + nSegmentDelimiter = '/'; + break; + + case FSYS_DOS: + nSegmentDelimiter = '\\'; + bRelativeNonURIs = true; + break; + + case FSYS_MAC: + nSegmentDelimiter = ':'; + bRelativeNonURIs = true; + break; + + default: + DBG_ERROR("INetURLObject::convertRelToAbs():" + " Bad guessFSysStyleByCounting"); + break; + } + + if (bRelativeNonURIs) + { + eMechanism = ENCODE_ALL; + nQueryDelimiter = 0x80000000; + nFragmentDelimiter = 0x80000000; + ePart = PART_VISIBLE_NONSPECIAL; + } + } + + // If the relative URI has the same scheme as the base URI, and that + // scheme is hierarchical, then ignore its presence in the relative + // URI in order to be backward compatible (cf. RFC 2396 section 5.2 + // step 3): + if (pPrefix && pPrefix->m_eScheme == m_eScheme + && getSchemeInfo().m_bHierarchical) + { + pPrefix = 0; + while (p != pEnd && *p++ != ':'); + } + rWasAbsolute = pPrefix != 0; + + // Fast solution for non-relative URIs: + if (pPrefix) + { + INetURLObject aNewURI(rTheRelURIRef, eMechanism, eCharset); + if (aNewURI.HasError()) + { + rWasAbsolute = false; + return false; + } + + if (bIgnoreFragment) + aNewURI.clearFragment(); + rTheAbsURIRef = aNewURI; + return true; + } + + UniString aSynAbsURIRef(UniString::CreateFromAscii(getSchemeInfo(). + m_pScheme)); + aSynAbsURIRef += ':'; + + sal_Char cEscapePrefix = getEscapePrefix(); + + enum State { STATE_AUTH, STATE_ABS_PATH, STATE_REL_PATH, STATE_FRAGMENT, + STATE_DONE }; + State eState = STATE_AUTH; + bool bSameDoc = true; + + if (getSchemeInfo().m_bAuthority) + if (pEnd - p >= 2 && p[0] == '/' && p[1] == '/') + { + aSynAbsURIRef.AppendAscii(RTL_CONSTASCII_STRINGPARAM("//")); + p += 2; + eState = STATE_ABS_PATH; + bSameDoc = false; + while (p != pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 + = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, + eCharset, eEscapeType); + if (eEscapeType == ESCAPE_NO) + if (nUTF32 == nSegmentDelimiter) + break; + else if (nUTF32 == nFragmentDelimiter) + { + eState = STATE_FRAGMENT; + break; + } + appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, + PART_VISIBLE, cEscapePrefix, eCharset, true); + } + } + else + { + SubString aAuthority(getAuthority()); + aSynAbsURIRef.Append(m_aAbsURIRef.GetBuffer() + + aAuthority.getBegin(), + aAuthority.getLength()); + } + + if (eState == STATE_AUTH) + if (p == pEnd) + eState = STATE_DONE; + else if (*p == nFragmentDelimiter) + { + ++p; + eState = STATE_FRAGMENT; + } + else if (*p == nSegmentDelimiter) + { + ++p; + eState = STATE_ABS_PATH; + bSameDoc = false; + } + else + { + eState = STATE_REL_PATH; + bSameDoc = false; + } + + if (eState == STATE_ABS_PATH) + { + aSynAbsURIRef += '/'; + eState = STATE_DONE; + while (p != pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 + = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, + eCharset, eEscapeType); + if (eEscapeType == ESCAPE_NO) + if (nUTF32 == nFragmentDelimiter) + { + eState = STATE_FRAGMENT; + break; + } + else if (nUTF32 == nSegmentDelimiter) + nUTF32 = '/'; + appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, + cEscapePrefix, eCharset, true); + } + } + else if (eState == STATE_REL_PATH) + { + if (!getSchemeInfo().m_bHierarchical) + { + rWasAbsolute = false; + return false; + } + + sal_Unicode const * pBasePathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pBasePathEnd + = pBasePathBegin + m_aPath.getLength(); + while (pBasePathEnd != pBasePathBegin) + if (*(--pBasePathEnd) == '/') + { + ++pBasePathEnd; + break; + } + + xub_StrLen nPathBegin = aSynAbsURIRef.Len(); + aSynAbsURIRef.Append(pBasePathBegin, pBasePathEnd - pBasePathBegin); + DBG_ASSERT(aSynAbsURIRef.Len() > nPathBegin + && aSynAbsURIRef.GetChar(aSynAbsURIRef.Len() - 1) == '/', + "INetURLObject::convertRelToAbs(): Bad base path"); + + while (p != pEnd && *p != nQueryDelimiter && *p != nFragmentDelimiter) + { + if (*p == '.') + if (pEnd - p == 1 + || p[1] == nSegmentDelimiter + || p[1] == nQueryDelimiter + || p[1] == nFragmentDelimiter) + { + ++p; + if (p != pEnd && *p == nSegmentDelimiter) + ++p; + continue; + } + else if (pEnd - p >= 2 + && p[1] == '.' + && (pEnd - p == 2 + || p[2] == nSegmentDelimiter + || p[2] == nQueryDelimiter + || p[2] == nFragmentDelimiter) + && aSynAbsURIRef.Len() - nPathBegin > 1) + { + p += 2; + if (p != pEnd && *p == nSegmentDelimiter) + ++p; + + xub_StrLen i = aSynAbsURIRef.Len() - 2; + while (i > nPathBegin && aSynAbsURIRef.GetChar(i) != '/') + --i; + aSynAbsURIRef.Erase(i + 1); + DBG_ASSERT( + aSynAbsURIRef.Len() > nPathBegin + && aSynAbsURIRef.GetChar(aSynAbsURIRef.Len() - 1) + == '/', + "INetURLObject::convertRelToAbs(): Bad base path"); + continue; + } + + while (p != pEnd + && *p != nSegmentDelimiter + && *p != nQueryDelimiter + && *p != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 + = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, + cEscapePrefix, eCharset, true); + } + if (p != pEnd && *p == nSegmentDelimiter) + { + aSynAbsURIRef += '/'; + ++p; + } + } + + while (p != pEnd && *p != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 + = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, ePart, + cEscapePrefix, eCharset, true); + } + + if (p == pEnd) + eState = STATE_DONE; + else + { + ++p; + eState = STATE_FRAGMENT; + } + } + else if (bSameDoc) + { + aSynAbsURIRef.Append(m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(), + m_aPath.getLength()); + if (m_aQuery.isPresent()) + aSynAbsURIRef.Append(m_aAbsURIRef.GetBuffer() + + m_aQuery.getBegin() - 1, + m_aQuery.getLength() + 1); + } + + if (eState == STATE_FRAGMENT && !bIgnoreFragment) + { + aSynAbsURIRef += '#'; + while (p != pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 + = getUTF32(p, pEnd, bOctets, cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aSynAbsURIRef, nUTF32, eEscapeType, bOctets, + PART_VISIBLE, cEscapePrefix, eCharset, true); + } + } + + INetURLObject aNewURI(aSynAbsURIRef); + if (aNewURI.HasError()) + { + rWasAbsolute = false; + return false; + } + + rTheAbsURIRef = aNewURI; + return true; +} + +//============================================================================ +bool INetURLObject::convertAbsToRel(UniString const & rTheAbsURIRef, + bool bOctets, UniString & rTheRelURIRef, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset, + FSysStyle eStyle) const +{ + // Check for hierarchical base URL: + if (!getSchemeInfo().m_bHierarchical) + { + rTheRelURIRef + = decode(rTheAbsURIRef, + getEscapePrefix(CompareProtocolScheme(rTheAbsURIRef)), + eDecodeMechanism, eCharset); + return false; + } + + // Convert the input (absolute URI ref, relative URI ref, file path) to an + // absolute URI ref: + INetURLObject aSubject; + bool bWasAbsolute; + if (!convertRelToAbs(rTheAbsURIRef, bOctets, aSubject, bWasAbsolute, + eEncodeMechanism, eCharset, false, true, false, + eStyle)) + { + rTheRelURIRef + = decode(rTheAbsURIRef, + getEscapePrefix(CompareProtocolScheme(rTheAbsURIRef)), + eDecodeMechanism, eCharset); + return false; + } + + // Check for differing scheme or authority parts: + if (m_eScheme != aSubject.m_eScheme + || !m_aUser.equals(aSubject.m_aUser, m_aAbsURIRef, + aSubject.m_aAbsURIRef) + || !m_aAuth.equals(aSubject.m_aAuth, m_aAbsURIRef, + aSubject.m_aAbsURIRef) + || !m_aHost.equals(aSubject.m_aHost, m_aAbsURIRef, + aSubject.m_aAbsURIRef) + || !m_aPort.equals(aSubject.m_aPort, m_aAbsURIRef, + aSubject.m_aAbsURIRef)) + { + rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); + return false; + } + + sal_Unicode const * pBasePathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pBasePathEnd = pBasePathBegin + m_aPath.getLength(); + sal_Unicode const * pSubjectPathBegin + = aSubject.m_aAbsURIRef.GetBuffer() + aSubject.m_aPath.getBegin(); + sal_Unicode const * pSubjectPathEnd + = pSubjectPathBegin + aSubject.m_aPath.getLength(); + + // Make nMatch point past the last matching slash, or past the end of the + // paths, in case they are equal: + sal_Unicode const * pSlash = 0; + sal_Unicode const * p1 = pBasePathBegin; + sal_Unicode const * p2 = pSubjectPathBegin; + for (;;) + { + if (p1 == pBasePathEnd || p2 == pSubjectPathEnd) + { + if (p1 == pBasePathEnd && p2 == pSubjectPathEnd) + pSlash = p1; + break; + } + + sal_Unicode c = *p1++; + if (c != *p2++) + break; + if (c == '/') + pSlash = p1; + } + if (!pSlash) + { + // One of the paths does not start with '/': + rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); + return false; + } + sal_uInt32 nMatch = pSlash - pBasePathBegin; + + // For file URLs, if the common prefix of the two paths is only "/" (which + // covers different DOS volumes like "/a:" and "/b:"), the subject is not + // made relative (it could be, but some people don't like that): + if (m_eScheme == INET_PROT_FILE && nMatch <= 1) + { + rTheRelURIRef = aSubject.GetMainURL(eDecodeMechanism, eCharset); + return false; + } + + // For every slash in the base path after nMatch, a prefix of "../" is + // added to the new relative URL (if the common prefix of the two paths is + // only "/"---but see handling of file URLs above---, the complete subject + // path could go into the new relative URL instead, but some people don't + // like that): + UniString aSynRelURIRef; +// if (nMatch <= 1) nMatch = 0; else // see comment above + for (sal_Unicode const * p = pBasePathBegin + nMatch; p != pBasePathEnd; + ++p) + { + if (*p == '/') + aSynRelURIRef.AppendAscii(RTL_CONSTASCII_STRINGPARAM("../")); + } + + // If the new relative URL would start with "//" (i.e., it would be + // mistaken for a relative URL starting with an authority part), or if the + // new relative URL would neither be empty nor start with <"/"> nor start + // with <1*rseg> (i.e., it could be mistaken for an absolute URL starting + // with a scheme part), then the new relative URL is prefixed with "./": + if (aSynRelURIRef.Len() == 0) + if (pSubjectPathEnd - pSubjectPathBegin >= nMatch + 2 + && pSubjectPathBegin[nMatch] == '/' + && pSubjectPathBegin[nMatch + 1] == '/') + aSynRelURIRef.AppendAscii(RTL_CONSTASCII_STRINGPARAM("./")); + else + for (sal_Unicode const * p = pSubjectPathBegin + nMatch; + p != pSubjectPathEnd && *p != '/'; ++p) + if (mustEncode(*p, PART_REL_SEGMENT_EXTRA)) + { + aSynRelURIRef. + AppendAscii(RTL_CONSTASCII_STRINGPARAM("./")); + break; + } + + // The remainder of the subject path, starting at nMatch, is appended to + // the new relative URL: + sal_Char cEscapePrefix = getEscapePrefix(); + aSynRelURIRef += decode(pSubjectPathBegin + nMatch, pSubjectPathEnd, + cEscapePrefix, eDecodeMechanism, eCharset); + + // If the subject has defined query or fragment parts, they are appended + // to the new relative URL: + if (aSubject.m_aQuery.isPresent()) + { + aSynRelURIRef += '?'; + aSynRelURIRef += aSubject.decode(aSubject.m_aQuery, cEscapePrefix, + eDecodeMechanism, eCharset); + } + if (aSubject.m_aFragment.isPresent()) + { + aSynRelURIRef += '#'; + aSynRelURIRef += aSubject.decode(aSubject.m_aFragment, cEscapePrefix, + eDecodeMechanism, eCharset); + } + + rTheRelURIRef = aSynRelURIRef; + return true; +} + +//============================================================================ +// static +bool INetURLObject::convertIntToExt(UniString const & rTheIntURIRef, + bool bOctets, UniString & rTheExtURIRef, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset) +{ + sal_Char cEscapePrefix + = getEscapePrefix(CompareProtocolScheme(rTheIntURIRef)); + UniString aSynExtURIRef(encodeText(rTheIntURIRef, bOctets, PART_VISIBLE, + cEscapePrefix, NOT_CANONIC, eCharset, + true)); + sal_Unicode const * pBegin = aSynExtURIRef.GetBuffer(); + sal_Unicode const * pEnd = pBegin + aSynExtURIRef.Len(); + sal_Unicode const * p = pBegin; + PrefixInfo const * pPrefix = getPrefix(p, pEnd); + bool bConvert = pPrefix && pPrefix->m_eKind == PrefixInfo::INTERNAL; + if (bConvert) + aSynExtURIRef. + Replace(0, p - pBegin, + UniString::CreateFromAscii(pPrefix->m_pTranslatedPrefix)); + rTheExtURIRef = decode(aSynExtURIRef, cEscapePrefix, eDecodeMechanism, + eCharset); + return bConvert; +} + +//============================================================================ +// static +bool INetURLObject::convertExtToInt(UniString const & rTheExtURIRef, + bool bOctets, UniString & rTheIntURIRef, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset) +{ + sal_Char cEscapePrefix + = getEscapePrefix(CompareProtocolScheme(rTheExtURIRef)); + UniString aSynIntURIRef(encodeText(rTheExtURIRef, bOctets, PART_VISIBLE, + cEscapePrefix, NOT_CANONIC, eCharset, + true)); + sal_Unicode const * pBegin = aSynIntURIRef.GetBuffer(); + sal_Unicode const * pEnd = pBegin + aSynIntURIRef.Len(); + sal_Unicode const * p = pBegin; + PrefixInfo const * pPrefix = getPrefix(p, pEnd); + bool bConvert = pPrefix && pPrefix->m_eKind == PrefixInfo::EXTERNAL; + if (bConvert) + aSynIntURIRef. + Replace(0, p - pBegin, + UniString::CreateFromAscii(pPrefix->m_pTranslatedPrefix)); + rTheIntURIRef = decode(aSynIntURIRef, cEscapePrefix, eDecodeMechanism, + eCharset); + return bConvert; +} + +//============================================================================ +// static +INetURLObject::PrefixInfo const * +INetURLObject::getPrefix(sal_Unicode const *& rBegin, + sal_Unicode const * pEnd) +{ + static PrefixInfo const aMap[] + = { // dummy entry at front needed, because pLast may point here: + { 0, 0, INET_PROT_NOT_VALID, PrefixInfo::INTERNAL }, + { ".component:", "staroffice.component:", INET_PROT_COMPONENT, + PrefixInfo::INTERNAL }, + { ".uno:", "staroffice.uno:", INET_PROT_UNO, + PrefixInfo::INTERNAL }, + { "cid:", 0, INET_PROT_CID, PrefixInfo::OFFICIAL }, + { "data:", 0, INET_PROT_DATA, PrefixInfo::OFFICIAL }, + { "db:", "staroffice.db:", INET_PROT_DB, PrefixInfo::INTERNAL }, + { "file:", 0, INET_PROT_FILE, PrefixInfo::OFFICIAL }, + { "ftp:", 0, INET_PROT_FTP, PrefixInfo::OFFICIAL }, + { "http:", 0, INET_PROT_HTTP, PrefixInfo::OFFICIAL }, + { "https:", 0, INET_PROT_HTTPS, PrefixInfo::OFFICIAL }, + { "imap:", 0, INET_PROT_IMAP, PrefixInfo::OFFICIAL }, + { "javascript:", 0, INET_PROT_JAVASCRIPT, PrefixInfo::OFFICIAL }, + { "ldap:", 0, INET_PROT_LDAP, PrefixInfo::OFFICIAL }, + { "macro:", "staroffice.macro:", INET_PROT_MACRO, + PrefixInfo::INTERNAL }, + { "mailto:", 0, INET_PROT_MAILTO, PrefixInfo::OFFICIAL }, + { "news:", 0, INET_PROT_NEWS, PrefixInfo::OFFICIAL }, + { "out:", "staroffice.out:", INET_PROT_OUT, + PrefixInfo::INTERNAL }, + { "pop3:", "staroffice.pop3:", INET_PROT_POP3, + PrefixInfo::INTERNAL }, + { "private:", "staroffice.private:", INET_PROT_PRIV_SOFFICE, + PrefixInfo::INTERNAL }, + { "private:factory/", "staroffice.factory:", + INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, + { "private:helpid/", "staroffice.helpid:", INET_PROT_PRIV_SOFFICE, + PrefixInfo::INTERNAL }, + { "private:java/", "staroffice.java:", INET_PROT_PRIV_SOFFICE, + PrefixInfo::INTERNAL }, + { "private:searchfolder:", "staroffice.searchfolder:", + INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, + { "private:trashcan:", "staroffice.trashcan:", + INET_PROT_PRIV_SOFFICE, PrefixInfo::INTERNAL }, + { "slot:", "staroffice.slot:", INET_PROT_SLOT, + PrefixInfo::INTERNAL }, + { "staroffice.component:", ".component:", INET_PROT_COMPONENT, + PrefixInfo::EXTERNAL }, + { "staroffice.db:", "db:", INET_PROT_DB, PrefixInfo::EXTERNAL }, + { "staroffice.factory:", "private:factory/", + INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, + { "staroffice.helpid:", "private:helpid/", INET_PROT_PRIV_SOFFICE, + PrefixInfo::EXTERNAL }, + { "staroffice.java:", "private:java/", INET_PROT_PRIV_SOFFICE, + PrefixInfo::EXTERNAL }, + { "staroffice.macro:", "macro:", INET_PROT_MACRO, + PrefixInfo::EXTERNAL }, + { "staroffice.out:", "out:", INET_PROT_OUT, + PrefixInfo::EXTERNAL }, + { "staroffice.pop3:", "pop3:", INET_PROT_POP3, + PrefixInfo::EXTERNAL }, + { "staroffice.private:", "private:", INET_PROT_PRIV_SOFFICE, + PrefixInfo::EXTERNAL }, + { "staroffice.searchfolder:", "private:searchfolder:", + INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, + { "staroffice.slot:", "slot:", INET_PROT_SLOT, + PrefixInfo::EXTERNAL }, + { "staroffice.trashcan:", "private:trashcan:", + INET_PROT_PRIV_SOFFICE, PrefixInfo::EXTERNAL }, + { "staroffice.uno:", ".uno:", INET_PROT_UNO, + PrefixInfo::EXTERNAL }, + { "staroffice.vim:", "vim:", INET_PROT_VIM, + PrefixInfo::EXTERNAL }, + { "staroffice:", "private:", INET_PROT_PRIV_SOFFICE, + PrefixInfo::EXTERNAL }, + { "vim:", "staroffice.vim:", INET_PROT_VIM, + PrefixInfo::INTERNAL } }; + PrefixInfo const * pFirst = aMap + 1; + PrefixInfo const * pLast = aMap + sizeof aMap / sizeof (PrefixInfo) - 1; + PrefixInfo const * pMatch = 0; + sal_Unicode const * pMatched = rBegin; + sal_Unicode const * p = rBegin; + xub_StrLen i = 0; + for (; pFirst < pLast; ++i) + { + if (pFirst->m_pPrefix[i] == '\0') + { + pMatch = pFirst++; + pMatched = p; + } + if (p >= pEnd) + break; + sal_uInt32 nChar = INetMIME::toLowerCase(*p++); + while (pFirst <= pLast && pFirst->m_pPrefix[i] < nChar) + ++pFirst; + while (pFirst <= pLast && pLast->m_pPrefix[i] > nChar) + --pLast; + } + if (pFirst == pLast) + { + sal_Char const * q = pFirst->m_pPrefix + i; + while (p < pEnd && *q != '\0' && INetMIME::toLowerCase(*p) == *q) + { + ++p; + ++q; + } + if (*q == '\0') + { + rBegin = p; + return pFirst; + } + } + rBegin = pMatched; + return pMatch; +} + +//============================================================================ +INetURLObject::SubString INetURLObject::getAuthority() const +{ + DBG_ASSERT(getSchemeInfo().m_bAuthority, + "INetURLObject::getAuthority(): Bad scheme"); + + xub_StrLen nBegin; + if (m_aUser.isPresent()) + nBegin = m_aUser.getBegin(); + else if (m_aHost.isPresent()) + nBegin = m_aHost.getBegin(); + else + nBegin = m_aPath.getBegin(); + nBegin -= RTL_CONSTASCII_LENGTH("//"); + DBG_ASSERT(m_aAbsURIRef.GetChar(nBegin) == '/' + && m_aAbsURIRef.GetChar(nBegin + 1) == '/', + "INetURLObject::getAuthority(): Bad authority"); + + xub_StrLen nEnd = m_aPort.isPresent() ? m_aPort.getEnd() : + m_aHost.isPresent() ? m_aHost.getEnd() : + m_aAuth.isPresent() ? m_aAuth.getEnd() : + m_aUser.isPresent() ? m_aUser.getEnd() : + nBegin + RTL_CONSTASCII_LENGTH("//"); + return SubString(nBegin, nEnd - nBegin); +} + +//============================================================================ +bool INetURLObject::setUser(UniString const & rTheUser, + bool bOctets, EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (!getSchemeInfo().m_bUser + || m_eScheme == INET_PROT_IMAP && rTheUser.Len() == 0) + return false; + UniString aNewUser(encodeText(rTheUser, bOctets, + m_eScheme == INET_PROT_IMAP ? + PART_IMAP_ACHAR : + m_eScheme == INET_PROT_VIM ? + PART_VIM : + PART_USER_PASSWORD, + getEscapePrefix(), eMechanism, eCharset, + false)); + sal_Int32 nDelta; + if (m_aUser.isPresent()) + nDelta = m_aUser.set(m_aAbsURIRef, aNewUser); + else if (m_aHost.isPresent()) + { + m_aAbsURIRef.Insert('@', m_aHost.getBegin()); + nDelta = m_aUser.set(m_aAbsURIRef, aNewUser, m_aHost.getBegin()) + 1; + } + else if (getSchemeInfo().m_bHost) + return false; + else + nDelta = m_aUser.set(m_aAbsURIRef, aNewUser, m_aPath.getBegin()); + m_aAuth += nDelta; + m_aHost += nDelta; + m_aPort += nDelta; + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + return true; +} + +//============================================================================ +bool INetURLObject::clearPassword() +{ + if (!getSchemeInfo().m_bPassword) + return false; + if (m_aAuth.isPresent()) + { + m_aAbsURIRef.Erase(m_aAuth.getBegin() - 1, m_aAuth.getLength() + 1); + sal_Int32 nDelta = m_aAuth.clear() - 1; + m_aHost += nDelta; + m_aPort += nDelta; + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + } + return true; +} + +//============================================================================ +bool INetURLObject::setPassword(UniString const & rThePassword, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (!getSchemeInfo().m_bPassword) + return false; + UniString aNewAuth(encodeText(rThePassword, bOctets, + m_eScheme == INET_PROT_VIM ? + PART_VIM : PART_USER_PASSWORD, + getEscapePrefix(), eMechanism, eCharset, + false)); + sal_Int32 nDelta; + if (m_aAuth.isPresent()) + nDelta = m_aAuth.set(m_aAbsURIRef, aNewAuth); + else if (m_aUser.isPresent()) + { + m_aAbsURIRef.Insert(':', m_aUser.getEnd()); + nDelta + = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aUser.getEnd() + 1) + 1; + } + else if (m_aHost.isPresent()) + { + m_aAbsURIRef.InsertAscii(":@", m_aHost.getBegin()); + m_aUser.set(m_aAbsURIRef, UniString(), m_aHost.getBegin()); + nDelta + = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aHost.getBegin() + 1) + 2; + } + else if (getSchemeInfo().m_bHost) + return false; + else + { + m_aAbsURIRef.Insert(':', m_aPath.getBegin()); + m_aUser.set(m_aAbsURIRef, UniString(), m_aPath.getBegin()); + nDelta + = m_aAuth.set(m_aAbsURIRef, aNewAuth, m_aPath.getBegin() + 1) + 1; + } + m_aHost += nDelta; + m_aPort += nDelta; + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + return true; +} + +//============================================================================ +// static +UniString INetURLObject::encodeHostPort(UniString const & rTheHostPort, + bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + xub_StrLen nPort = rTheHostPort.Len(); + if (rTheHostPort.Len() != 0) + { + xub_StrLen i = rTheHostPort.Len() - 1; + while (i != 0 && INetMIME::isDigit(rTheHostPort.GetChar(i))) + --i; + if (rTheHostPort.GetChar(i) == ':') + nPort = i; + } + UniString aResult(encodeText(rTheHostPort.Copy(0, nPort), bOctets, + PART_HOST_EXTRA, '%', eMechanism, eCharset, + true)); + aResult += rTheHostPort.Copy(nPort); + return aResult; +} + +//============================================================================ +bool INetURLObject::setHost(UniString const & rTheHost, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (!getSchemeInfo().m_bHost) + return false; + UniString aSynHost(rTheHost); + switch (m_eScheme) + { + case INET_PROT_FILE: + if (aSynHost.EqualsIgnoreCaseAscii("localhost")) + aSynHost.Erase(); + break; + + case INET_PROT_LDAP: + if (aSynHost.Len() == 0 && m_aPort.isPresent()) + return false; + break; + + default: + if (aSynHost.Len() == 0) + return false; + break; + } + if (aSynHost.Len() != 0) + { + sal_Unicode const * p = aSynHost.GetBuffer(); + sal_Unicode const * pEnd = p + aSynHost.Len(); + if (!parseHost(p, pEnd, bOctets, eMechanism, eCharset, aSynHost) + || p != pEnd) + return false; + } + sal_Int32 nDelta = m_aHost.set(m_aAbsURIRef, aSynHost); + m_aPort += nDelta; + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + return true; +} + +//============================================================================ +bool INetURLObject::parsePath(sal_Unicode const ** pBegin, + sal_Unicode const * pEnd, + bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + bool bSkippedInitialSlash, + sal_uInt32 nSegmentDelimiter, + sal_uInt32 nAltSegmentDelimiter, + sal_uInt32 nQueryDelimiter, + sal_uInt32 nFragmentDelimiter, + UniString * pSynPath) +{ + DBG_ASSERT(pBegin && pSynPath, + "INetURLObject::parsePath(): Null output param"); + + sal_Char cEscapePrefix = getEscapePrefix(); + + sal_Unicode const * pPos = *pBegin; + UniString aTheSynPath; + + switch (m_eScheme) + { + case INET_PROT_NOT_VALID: + return false; + + case INET_PROT_FTP: + case INET_PROT_IMAP: + if (pPos < pEnd && *pPos != '/') + { + setInvalid(); + return false; + } + while (pPos < pEnd && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_HTTP_PATH, cEscapePrefix, eCharset, true); + } + if (aTheSynPath.Len() == 0) + aTheSynPath = '/'; + break; + + case INET_PROT_HTTP: + case INET_PROT_HTTPS: + if (pPos < pEnd && *pPos != '/') + { + setInvalid(); + return false; + } + while (pPos < pEnd && *pPos != nQueryDelimiter + && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_HTTP_PATH, cEscapePrefix, eCharset, true); + } + if (aTheSynPath.Len() == 0) + aTheSynPath = '/'; + break; + + case INET_PROT_FILE: + { + if (bSkippedInitialSlash) + aTheSynPath = '/'; + else if (pPos < pEnd + && *pPos != nSegmentDelimiter + && *pPos != nAltSegmentDelimiter) + { + setInvalid(); + return false; + } + while (pPos < pEnd && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + if (eEscapeType == ESCAPE_NO) + if (nUTF32 == nSegmentDelimiter + || nUTF32 == nAltSegmentDelimiter) + { + aTheSynPath += '/'; + continue; + } + else if (nUTF32 == '|' + && (pPos == pEnd + || *pPos == nFragmentDelimiter + || *pPos == nSegmentDelimiter + || *pPos == nAltSegmentDelimiter) + && aTheSynPath.Len() == 2 + && INetMIME::isAlpha(aTheSynPath.GetChar(1))) + { + // A first segment of <ALPHA "|"> is translated to + // <ALPHA ":">: + aTheSynPath += ':'; + continue; + } + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_PCHAR, cEscapePrefix, eCharset, true); + } + if (aTheSynPath.Len() == 0) + aTheSynPath = '/'; + break; + } + + case INET_PROT_MAILTO: + while (pPos < pEnd && *pPos != nQueryDelimiter + && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_MAILTO, cEscapePrefix, eCharset, true); + } + break; + + case INET_PROT_NEWS: + case INET_PROT_POP3: + while (pPos < pEnd && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_MESSAGE_ID_PATH, cEscapePrefix, eCharset, + true); + } + break; + + case INET_PROT_PRIV_SOFFICE: + case INET_PROT_SLOT: + case INET_PROT_MACRO: + case INET_PROT_COMPONENT: + case INET_PROT_LDAP: + while (pPos < pEnd && *pPos != nQueryDelimiter + && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_PATH_BEFORE_QUERY, cEscapePrefix, eCharset, + true); + } + break; + + case INET_PROT_JAVASCRIPT: + case INET_PROT_DATA: + case INET_PROT_CID: + case INET_PROT_UNO: + case INET_PROT_DB: + while (pPos < pEnd && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_URIC, cEscapePrefix, eCharset, true); + } + break; + + case INET_PROT_OUT: + if (pEnd - pPos < 2 || *pPos++ != '/' || *pPos++ != '~') + { + setInvalid(); + return false; + } + aTheSynPath.AssignAscii(RTL_CONSTASCII_STRINGPARAM("/~")); + while (pPos < pEnd && *pPos != nFragmentDelimiter) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_URIC, cEscapePrefix, eCharset, true); + } + break; + + case INET_PROT_VIM: + { + if (m_aUser.isEmpty()) + { + setInvalid(); + return false; + } + sal_Unicode const * pPathEnd = pPos; + while (pPathEnd < pEnd && *pPathEnd != nFragmentDelimiter) + ++pPathEnd; + aTheSynPath = '/'; + if (pPos == pPathEnd) + break; + else if (*pPos++ != '/') + { + setInvalid(); + return false; + } + if (pPos == pPathEnd) + break; + while (pPos < pPathEnd && *pPos != '/') + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, + eEscapeType == ESCAPE_NO ? + INetMIME::toLowerCase(nUTF32) : nUTF32, + eEscapeType, bOctets, PART_VIM, cEscapePrefix, + eCharset, false); + } + bool bInbox; + if (aTheSynPath.EqualsAscii("/inbox")) + bInbox = true; + else if (aTheSynPath.EqualsAscii("/newsgroups")) + bInbox = false; + else + { + setInvalid(); + return false; + } + aTheSynPath += '/'; + if (pPos == pPathEnd) + break; + else if (*pPos++ != '/') + { + setInvalid(); + return false; + } + if (!bInbox) + { + bool bEmpty = true; + while (pPos < pPathEnd && *pPos != '/') + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_VIM, cEscapePrefix, eCharset, false); + bEmpty = false; + } + if (bEmpty) + { + setInvalid(); + return false; + } + aTheSynPath += '/'; + if (pPos == pPathEnd) + break; + else if (*pPos++ != '/') + { + setInvalid(); + return false; + } + } + bool bEmpty = true; + while (pPos < pPathEnd && *pPos != ':') + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + appendUCS4(aTheSynPath, nUTF32, eEscapeType, bOctets, + PART_VIM, cEscapePrefix, eCharset, false); + bEmpty = false; + } + if (bEmpty) + { + setInvalid(); + return false; + } + if (pPos == pPathEnd) + break; + else if (*pPos++ != ':') + { + setInvalid(); + return false; + } + aTheSynPath += ':'; + for (int i = 0; i < 3; ++i) + { + if (i != 0) + { + if (pPos == pPathEnd || *pPos++ != '.') + { + setInvalid(); + return false; + } + aTheSynPath += '.'; + } + bool bEmpty = true; + while (pPos < pPathEnd && *pPos != '.') + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pPos, pPathEnd, bOctets, + cEscapePrefix, eMechanism, + eCharset, eEscapeType); + if (!INetMIME::isDigit(nUTF32)) + { + setInvalid(); + return false; + } + aTheSynPath += sal_Unicode(nUTF32); + bEmpty = false; + } + if (bEmpty) + { + setInvalid(); + return false; + } + } + if (pPos != pPathEnd) + { + setInvalid(); + return false; + } + break; + } + } + + *pBegin = pPos; + *pSynPath = aTheSynPath; + return true; +} + +//============================================================================ +bool INetURLObject::setPath(UniString const & rThePath, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + UniString aSynPath; + sal_Unicode const * p = rThePath.GetBuffer(); + if (!parsePath(&p, p + rThePath.Len(), bOctets, eMechanism, eCharset, + false, '/', 0x80000000, 0x80000000, 0x80000000, &aSynPath)) + return false; + sal_Int32 nDelta = m_aPath.set(m_aAbsURIRef, aSynPath); + m_aQuery += nDelta; + m_aFragment += nDelta; + return true; +} + +//============================================================================ +bool INetURLObject::appendSegment(UniString const & rTheSegment, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + return insertName(rTheSegment, bOctets, false, LAST_SEGMENT, true, + eMechanism, eCharset); +} + +//============================================================================ +INetURLObject::SubString INetURLObject::getSegment(sal_Int32 nIndex, + bool bIgnoreFinalSlash) + const +{ + DBG_ASSERT(nIndex >= 0 || nIndex == LAST_SEGMENT, + "INetURLObject::getSegment(): Bad index"); + + if (!getSchemeInfo().m_bHierarchical) + return SubString(); + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + if (pPathBegin == pPathEnd || *pPathBegin != '/') + return SubString(); + + sal_Unicode const * pSegBegin; + sal_Unicode const * pSegEnd; + if (nIndex == LAST_SEGMENT) + { + pSegEnd = pPathEnd; + if (bIgnoreFinalSlash && pSegEnd[-1] == '/' + && pSegEnd != pPathBegin + 1) + --pSegEnd; + pSegBegin = pSegEnd - 1; + while (*pSegBegin != '/') + --pSegBegin; + } + else + { + pSegBegin = pPathBegin; + pSegEnd = pPathEnd; + if (bIgnoreFinalSlash && pSegEnd[-1] == '/') + --pSegEnd; + while (nIndex-- > 0) + do + { + ++pSegBegin; + if (pSegBegin >= pSegEnd) + return SubString(); + } + while (*pSegBegin != '/'); + pSegEnd = pSegBegin + 1; + while (pSegEnd != pPathEnd && *pSegEnd != '/') + ++pSegEnd; + } + + return SubString(pSegBegin - m_aAbsURIRef.GetBuffer(), + pSegEnd - pSegBegin); +} + +//============================================================================ +bool INetURLObject::insertName(UniString const & rTheName, bool bOctets, + bool bAppendFinalSlash, sal_Int32 nIndex, + bool bIgnoreFinalSlash, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + DBG_ASSERT(nIndex >= 0 || nIndex == LAST_SEGMENT, + "INetURLObject::insertName(): Bad index"); + + if (!getSchemeInfo().m_bHierarchical) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + if (pPathBegin == pPathEnd || *pPathBegin != '/') + return false; + + sal_Unicode const * pPrefixEnd; + sal_Unicode const * pSuffixBegin; + bool bPrefixSlash = true; + if (nIndex == LAST_SEGMENT) + { + pPrefixEnd = pPathEnd; + if (bIgnoreFinalSlash && pPrefixEnd[-1] == '/') + bPrefixSlash = false; + pSuffixBegin = bAppendFinalSlash ? 0 : pPathEnd; + } + else + { + pPrefixEnd = pPathBegin; + sal_Unicode const * pEnd = pPathEnd; + if (bIgnoreFinalSlash && pEnd[-1] == '/') + --pEnd; + while (nIndex-- > 0) + for (;;) + { + ++pPrefixEnd; + if (pPrefixEnd >= pEnd) + if (nIndex == 0) + { + pSuffixBegin = bAppendFinalSlash ? 0 : pPathEnd; + break; + } + else + return false; + if (*pPrefixEnd == '/') + { + pSuffixBegin = pPrefixEnd; + break; + } + } + } + + UniString aNewPath(pPathBegin, pPrefixEnd - pPathBegin); + if (bPrefixSlash) + aNewPath += '/'; + aNewPath += encodeText(rTheName, bOctets, PART_PCHAR, getEscapePrefix(), + eMechanism, eCharset, true); + if (pSuffixBegin) + aNewPath.Append(pSuffixBegin, pPathEnd - pSuffixBegin); + else + aNewPath += '/'; + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +bool INetURLObject::clearQuery() +{ + if (HasError()) + return false; + if (m_aQuery.isPresent()) + { + m_aAbsURIRef.Erase(m_aQuery.getBegin() - 1, m_aQuery.getLength() + 1); + m_aFragment += m_aQuery.clear() - 1; + } + return false; +} + +//============================================================================ +bool INetURLObject::setQuery(UniString const & rTheQuery, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (!getSchemeInfo().m_bQuery) + return false; + UniString aNewQuery(encodeText(rTheQuery, bOctets, PART_URIC, + getEscapePrefix(), eMechanism, eCharset, + true)); + sal_Int32 nDelta; + if (m_aQuery.isPresent()) + nDelta = m_aQuery.set(m_aAbsURIRef, aNewQuery); + else + { + m_aAbsURIRef.Insert('?', m_aPath.getEnd()); + nDelta = m_aQuery.set(m_aAbsURIRef, aNewQuery, m_aPath.getEnd() + 1) + + 1; + } + m_aFragment += nDelta; + return true; +} + +//============================================================================ +bool INetURLObject::clearFragment() +{ + if (HasError()) + return false; + if (m_aFragment.isPresent()) + { + m_aAbsURIRef.Erase(m_aFragment.getBegin() - 1); + m_aFragment.clear(); + } + return true; +} + +//============================================================================ +bool INetURLObject::setFragment(UniString const & rTheFragment, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (HasError()) + return false; + UniString aNewFragment(encodeText(rTheFragment, bOctets, PART_URIC, + getEscapePrefix(), eMechanism, + eCharset, true)); + if (m_aFragment.isPresent()) + m_aFragment.set(m_aAbsURIRef, aNewFragment); + else + { + m_aAbsURIRef.Append('#'); + m_aFragment.set(m_aAbsURIRef, aNewFragment, m_aAbsURIRef.Len()); + } + return true; +} + +//============================================================================ +INetURLObject::FTPType INetURLObject::getFTPType() const +{ + if (m_eScheme == INET_PROT_FTP + && m_aPath.getLength() >= RTL_CONSTASCII_LENGTH(";type=") + 1 + && m_aAbsURIRef. + EqualsIgnoreCaseAscii(";type=", + m_aPath.getEnd() + - (RTL_CONSTASCII_LENGTH(";type=") + + 1), + RTL_CONSTASCII_LENGTH(";type="))) + switch (m_aAbsURIRef.GetChar(m_aPath.getEnd())) + { + case 'A': + case 'a': + return FTP_TYPE_A; + + case 'D': + case 'd': + return FTP_TYPE_D; + + case 'I': + case 'i': + return FTP_TYPE_I; + } + return FTP_TYPE_NONE; +} + +//============================================================================ +sal_uInt32 INetURLObject::getIMAPUID() const +{ + if (m_eScheme == INET_PROT_IMAP + && m_aPath.getLength() >= RTL_CONSTASCII_LENGTH("/;uid=") + 1) + { + sal_Unicode const * pBegin = m_aAbsURIRef.GetBuffer() + + m_aPath.getBegin() + + RTL_CONSTASCII_LENGTH("/;uid="); + sal_Unicode const * pEnd = pBegin + m_aPath.getLength(); + sal_Unicode const * p = pEnd; + while (p > pBegin && INetMIME::isDigit(p[-1])) + --p; + if (p < pEnd && *--p != '0' + && m_aAbsURIRef. + EqualsIgnoreCaseAscii("/;uid=", + p - RTL_CONSTASCII_LENGTH("/;uid=") + - m_aAbsURIRef.GetBuffer(), + RTL_CONSTASCII_LENGTH("/;uid="))) + { + sal_uInt32 nUID; + if (INetMIME::scanUnsigned(p, pEnd, false, nUID)) + return nUID; + } + } + return 0; +} + +//============================================================================ +// static +UniString INetURLObject::encodeText(sal_Unicode const * pBegin, + sal_Unicode const * pEnd, bool bOctets, + Part ePart, sal_Char cEscapePrefix, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + bool bKeepVisibleEscapes) +{ + UniString aResult; + while (pBegin < pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pBegin, pEnd, bOctets, cEscapePrefix, + eMechanism, eCharset, eEscapeType); + appendUCS4(aResult, nUTF32, eEscapeType, bOctets, ePart, + cEscapePrefix, eCharset, bKeepVisibleEscapes); + } + return aResult; +} + +//============================================================================ +// static +UniString INetURLObject::decode(sal_Unicode const * pBegin, + sal_Unicode const * pEnd, + sal_Char cEscapePrefix, + DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + switch (eMechanism) + { + case NO_DECODE: + return UniString(pBegin, pEnd - pBegin); + + case DECODE_TO_IURI: + eCharset = RTL_TEXTENCODING_UTF8; + break; + } + UniString aResult; + while (pBegin < pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(pBegin, pEnd, false, cEscapePrefix, + WAS_ENCODED, eCharset, eEscapeType); + switch (eEscapeType) + { + case ESCAPE_NO: + aResult += sal_Unicode(nUTF32); + break; + + case ESCAPE_OCTET: + appendEscape(aResult, cEscapePrefix, nUTF32); + break; + + case ESCAPE_UTF32: + if (INetMIME::isUSASCII(nUTF32) + && (eMechanism == DECODE_TO_IURI + || eMechanism == DECODE_UNAMBIGUOUS + && mustEncode(nUTF32, PART_UNAMBIGUOUS))) + appendEscape(aResult, cEscapePrefix, nUTF32); + else + aResult += sal_Unicode(nUTF32); + break; + } + } + return aResult; +} + +//============================================================================ +UniString INetURLObject::GetURLNoPass(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + INetURLObject aTemp(*this); + aTemp.clearPassword(); + return aTemp.GetMainURL(eMechanism, eCharset); +} + +//============================================================================ +UniString INetURLObject::GetURLNoMark(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + INetURLObject aTemp(*this); + aTemp.clearFragment(); + return aTemp.GetMainURL(eMechanism, eCharset); +} + +//============================================================================ +bool INetURLObject::operator ==(INetURLObject const & rObject) const +{ + if (m_eScheme != rObject.m_eScheme) + return false; + if (m_eScheme == INET_PROT_NOT_VALID) + return (m_aAbsURIRef == rObject.m_aAbsURIRef) != false; + if (GetUser(NO_DECODE) != rObject.GetUser(NO_DECODE) + || GetPass(NO_DECODE) != rObject.GetPass(NO_DECODE) + || !GetHost(NO_DECODE).EqualsIgnoreCaseAscii(rObject. + GetHost(NO_DECODE)) + || GetPort() != rObject.GetPort() + || HasParam() != rObject.HasParam() + || GetParam(NO_DECODE) != rObject.GetParam(NO_DECODE) + || GetMsgId(NO_DECODE) != rObject.GetMsgId(NO_DECODE)) + return false; + UniString aPath1(GetURLPath(NO_DECODE)); + UniString aPath2(rObject.GetURLPath(NO_DECODE)); + if (m_eScheme == INET_PROT_FILE) + { + // If the URL paths of two file URLs only differ in that one has a + // final '/' and the other has not, take the two paths as equivalent + // (this could be usefull for other schemes, too): + xub_StrLen nLength = aPath1.Len(); + switch (sal_Int32(nLength) - sal_Int32(aPath2.Len())) + { + case -1: + if (aPath2.GetChar(nLength) != '/') + return false; + break; + + case 0: + break; + + case 1: + if (aPath1.GetChar(--nLength) != '/') + return false; + break; + + default: + return false; + } + return aPath1.CompareTo(aPath2, nLength) == COMPARE_EQUAL; + } + else + return (aPath1 == aPath2) != false; +} + +//============================================================================ +bool INetURLObject::operator <(INetURLObject const & rObject) const +{ + switch (GetScheme(m_eScheme).CompareTo(GetScheme(rObject.m_eScheme))) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + sal_uInt32 nPort1 = GetPort(); + sal_uInt32 nPort2 = rObject.GetPort(); + if (nPort1 < nPort2) + return true; + else if (nPort1 > nPort2) + return false; + switch (GetUser(NO_DECODE).CompareTo(rObject.GetUser(NO_DECODE))) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + switch (GetPass(NO_DECODE).CompareTo(rObject.GetPass(NO_DECODE))) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + switch (GetHost(NO_DECODE).CompareTo(rObject.GetHost(NO_DECODE))) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + UniString aPath1(GetURLPath(NO_DECODE)); + UniString aPath2(rObject.GetURLPath(NO_DECODE)); + switch (aPath1.CompareTo(aPath2)) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + switch (GetParam(NO_DECODE).CompareTo(rObject.GetParam(NO_DECODE))) + { + case COMPARE_LESS: + return true; + + case COMPARE_GREATER: + return false; + } + return GetMsgId(NO_DECODE).CompareTo(rObject.GetMsgId(NO_DECODE)) + == COMPARE_LESS; +} + +//============================================================================ +bool INetURLObject::ConcatData(INetProtocol eTheScheme, + UniString const & rTheUser, + UniString const & rThePassword, + UniString const & rTheHost, + sal_uInt32 nThePort, + UniString const & rThePath, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + setInvalid(); + m_eScheme = eTheScheme; + if (HasError()) + return false; + m_aAbsURIRef.AssignAscii(getSchemeInfo().m_pScheme); + m_aAbsURIRef += ':'; + if (getSchemeInfo().m_bAuthority) + { + m_aAbsURIRef.AppendAscii(RTL_CONSTASCII_STRINGPARAM("//")); + bool bUserInfo = false; + if (getSchemeInfo().m_bUser) + { + if (m_eScheme == INET_PROT_IMAP && rTheUser.Len() == 0) + { + setInvalid(); + return false; + } + if (rTheUser.Len() != 0) + { + m_aUser.set(m_aAbsURIRef, + encodeText(rTheUser, false, + m_eScheme == INET_PROT_IMAP ? + PART_IMAP_ACHAR : + m_eScheme == INET_PROT_VIM ? + PART_VIM : + PART_USER_PASSWORD, + getEscapePrefix(), eMechanism, + eCharset, false), + m_aAbsURIRef.Len()); + bUserInfo = true; + } + } + else if (rTheUser.Len() != 0) + { + setInvalid(); + return false; + } + if (rThePassword.Len() != 0) + if (getSchemeInfo().m_bPassword) + { + m_aAbsURIRef += ':'; + m_aAuth.set(m_aAbsURIRef, + encodeText(rThePassword, false, + m_eScheme == INET_PROT_VIM ? + PART_VIM : PART_USER_PASSWORD, + getEscapePrefix(), eMechanism, + eCharset, false), + m_aAbsURIRef.Len()); + bUserInfo = true; + } + else + { + setInvalid(); + return false; + } + if (bUserInfo && getSchemeInfo().m_bHost) + m_aAbsURIRef += '@'; + if (getSchemeInfo().m_bHost) + { + UniString aSynHost(rTheHost); + switch (m_eScheme) + { + case INET_PROT_FILE: + if (aSynHost.EqualsIgnoreCaseAscii("localhost")) + aSynHost.Erase(); + break; + + case INET_PROT_LDAP: + if (aSynHost.Len() == 0 && nThePort != 0) + { + setInvalid(); + return false; + } + break; + + default: + if (aSynHost.Len() == 0) + { + setInvalid(); + return false; + } + break; + } + if (aSynHost.Len() != 0) + { + sal_Unicode const * p = aSynHost.GetBuffer(); + sal_Unicode const * pEnd = p + aSynHost.Len(); + if (!parseHost(p, pEnd, false, eMechanism, eCharset, aSynHost) + || p != pEnd) + { + setInvalid(); + return false; + } + } + m_aHost.set(m_aAbsURIRef, aSynHost, m_aAbsURIRef.Len()); + if (nThePort != 0) + if (getSchemeInfo().m_bPort) + { + m_aAbsURIRef += ':'; + m_aPort.set(m_aAbsURIRef, + UniString::CreateFromInt64(nThePort), + m_aAbsURIRef.Len()); + } + else + { + setInvalid(); + return false; + } + } + else if (rTheHost.Len() != 0 || nThePort != 0) + { + setInvalid(); + return false; + } + } + UniString aSynPath; + if (getSchemeInfo().m_bHierarchical + && rThePath.Len() == 0 || rThePath.GetChar(0) != '/') + aSynPath = '/'; + aSynPath += rThePath; + m_aPath.set(m_aAbsURIRef, + encodeText(aSynPath, false, + m_eScheme == INET_PROT_FILE ? + PART_PATH_SEGMENTS_EXTRA : + m_eScheme == INET_PROT_NEWS + || m_eScheme == INET_PROT_POP3 ? + PART_MESSAGE_ID_PATH : + PART_HTTP_PATH, + getEscapePrefix(), eMechanism, eCharset, true), + m_aAbsURIRef.Len()); + return true; +} + +//============================================================================ +namespace unnamed_tools_urlobj { + +inline bool isWLetter(International const & rInternational, sal_Unicode c) +{ + return rInternational.IsAlphaNumeric(c) || c == '$' || c == '%' + || c == '&' || c == '-' || c == '/' || c == '@' || c == '\\'; +} + +inline bool checkWChar(International const & rInternational, + sal_Unicode const * p, sal_Unicode const *& rEnd, + bool bBackslash = false, bool bPipe = false) +{ + sal_Unicode c = *p; + if (rInternational.IsAlphaNumeric(c) || c == '/' + || c == '\\' && bBackslash || c == '|' && bPipe) + { + rEnd = p + 1; + return true; + } + else + return !mustEncode(c, INetURLObject::PART_URIC) || c == '%'; +} + +} + +// static +UniString INetURLObject::FindFirstURLInText(UniString const & rText, + xub_StrLen & rBegin, + xub_StrLen & rEnd, + International const & + rInternational, + UniString const *, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + if (!(rBegin <= rEnd && rEnd <= rText.Len())) + return UniString(); + + sal_Unicode const * pBegin = rText.GetBuffer() + rBegin; + sal_Unicode const * pEnd = rText.GetBuffer() + rEnd; + + // Search for the first (longest possible) substring of [pBegin..pEnd[ + // that matches any of the following productions. "\W" stands for a word + // break, i.e., the begin or end of the block of text, or a character that + // is neither a letter nor a digit (according to rInternational). The + // productions use the auxiliary rules + // + // domain = label *("." label) + // label = alphanum [*(alphanum / "-") alphanum] + // alphanum = ALPHA / DIGIT + // IPv6reference = "[" IPv6address "]" + // IPv6address = hexpart [":" IPv4address] + // IPv4address = 1*3DIGIT 3("." 1*3DIGIT) + // hexpart = (hexseq ["::" [hexseq]]) / ("::" [hexseq]) + // hexseq = hex4 *(":" hex4) + // hex4 = 1*4HEXDIG + // wchar = <any uric character (ignoring the escaped rule), or "%", or + // a letter or digit (according to rInternational)> + // + // 1st Production (file): + // \W "file:" 1*(wchar / "\" / "|") ["#" 1*wchar] \W + // + // 2nd Production (known scheme): + // \W <one of the known schemes, ignoring case> ":" 1*wchar + // ["#" 1*wchar] \W + // + // 3rd Production (mailto): + // \W domain "@" domain \W + // + // 4th Production (ftp): + // \W "ftp" 2*("." label) ["/" *wchar] ["#" 1*wchar] \W + // + // 5th Production (http): + // \W label 2*("." label) ["/" *wchar] ["#" 1*wchar] \W + // + // 6th Production (file): + // \W "//" (domain / IPv6reference) ["/" *wchar] ["#" 1*wchar] \W + // + // 7th Production (Unix file): + // \W "/" 1*wchar \W + // + // 8th Production (UNC file): + // \W "\\" domain ["\" *(wchar / "\")] \W + // + // 9th Production (Unix-like DOS file): + // \W ALPHA ":/" *wchar \W + // + // 10th Production (DOS file): + // \W ALPHA ":\" *(wchar / "\") \W + + for (sal_Unicode const * pPos = pBegin; pPos != pEnd;) + if ((INetMIME::isAlpha(*pPos) || *pPos == '/' || *pPos == '\\') + && (pPos == pBegin || !isWLetter(rInternational, pPos[-1]))) + { + sal_Unicode const * pURIEnd = 0; + + if (INetMIME::isAlpha(*pPos)) + { + sal_Unicode const * p = pPos; + sal_Unicode const * pPrefixEnd = p; + PrefixInfo const * pPrefix = getPrefix(pPrefixEnd, pEnd); + if (pPrefix) // 1st, 2nd + { + while (*p++ != ':'); + pPrefixEnd = p; + if (pPrefix->m_eScheme == INET_PROT_FILE) + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd, true, + true)) + ++p; + else + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + if (p != pPrefixEnd && *p == '#') + { + ++p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + } + } + else if (pEnd - p >= 3 && p[1] == ':' && p[2] == '/') // 9th + { + p += 3; + pURIEnd = p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + } + else if (pEnd - p >= 3 && p[1] == ':' && p[2] == '\\') // 10th + { + p += 3; + pURIEnd = p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd, true)) + ++p; + } + else + { + sal_uInt32 nLabels = scanDomain(p, pEnd, false); + if (nLabels > 0 && p != pEnd && *p == '@') // 3rd + { + ++p; + if (scanDomain(p, pEnd, false) > 0) + pURIEnd = p; + } + else if (nLabels >= 3) // 4th, 5th + { + pURIEnd = p; + if (p != pEnd && *p == '/') + { + pURIEnd = ++p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + } + if (p != pEnd && *p == '#') + { + ++p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + } + } + } + } + else if (*pPos == '/') + { + sal_Unicode const * p = pPos; + if (pEnd - p >= 2) + if (p[1] == '/') // 6th + { + p += 2; + if (scanDomain(p, pEnd, false) > 0 + || scanIPv6reference(p, pEnd, false)) + { + pURIEnd = p; + if (p != pEnd && *p == '/') + { + pURIEnd = ++p; + while (p != pEnd + && checkWChar(rInternational, p, + pURIEnd)) + ++p; + } + if (p != pEnd && *p == '#') + { + ++p; + while (p != pEnd + && checkWChar(rInternational, p, + pURIEnd)) + ++p; + } + } + } + else // 7th + { + ++p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd)) + ++p; + } + } + else if (*pPos == '\\') // 8th + { + sal_Unicode const * p = pPos; + if (pEnd - p >= 2 && p[1] == '\\') + { + p += 2; + if (scanDomain(p, pEnd, false) > 0) + { + pURIEnd = p; + if (p != pEnd && *p == '\\') + { + pURIEnd = ++p; + while (p != pEnd + && checkWChar(rInternational, p, pURIEnd, + true)) + ++p; + } + } + } + } + + if (pURIEnd + && (pURIEnd == pEnd || !isWLetter(rInternational, *pURIEnd))) + { + INetURLObject aURI(UniString(pPos, pURIEnd - pPos), + INET_PROT_HTTP, eMechanism, eCharset); + if (!aURI.HasError()) + { + rBegin += pPos - pBegin; + rEnd -= pEnd - pURIEnd; + return aURI.GetMainURL(); + } + } + + ++pPos; + while (pPos != pEnd && isWLetter(rInternational, *pPos)) + ++pPos; + } + else + ++pPos; + + rBegin = rEnd; + return UniString(); +} + +//============================================================================ +UniString INetURLObject::getExternalURL(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + UniString aTheExtURIRef; + translateToExternal(m_aAbsURIRef, aTheExtURIRef, NOT_CANONIC, eMechanism, + eCharset); + return aTheExtURIRef; +} + +//============================================================================ +// static +UniString INetURLObject::GetScheme(INetProtocol eTheScheme) +{ + return UniString::CreateFromAscii(getSchemeInfo(eTheScheme).m_pPrefix); +} + +//============================================================================ +// static +INetProtocol INetURLObject::CompareProtocolScheme(UniString const & + rTheAbsURIRef) +{ + sal_Unicode const * p = rTheAbsURIRef.GetBuffer(); + PrefixInfo const * pPrefix = getPrefix(p, p + rTheAbsURIRef.Len()); + return pPrefix ? pPrefix->m_eScheme : INET_PROT_NOT_VALID; +} + +//============================================================================ +bool INetURLObject::hasPassword() const +{ + return m_aAuth.isPresent() && getSchemeInfo().m_bPassword; +} + +//============================================================================ +void INetURLObject::makeAuthCanonic() +{ + if (m_eScheme == INET_PROT_IMAP && m_aAuth.getLength() == 1 + && m_aAbsURIRef.GetChar(m_aAuth.getBegin()) == '*') + { + m_aAbsURIRef.Erase(m_aAuth.getBegin() + - RTL_CONSTASCII_LENGTH(";AUTH="), + RTL_CONSTASCII_LENGTH(";AUTH=*")); + sal_Int32 nDelta = m_aAuth.clear() - RTL_CONSTASCII_LENGTH(";AUTH="); + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + } +} + +//============================================================================ +UniString INetURLObject::GetHostPort(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + UniString aHostPort(decode(m_aHost, getEscapePrefix(), eMechanism, + eCharset)); + if (m_aPort.isPresent()) + { + aHostPort += ':'; + aHostPort += decode(m_aPort, getEscapePrefix(), eMechanism, eCharset); + } + return aHostPort; +} + +//============================================================================ +sal_uInt32 INetURLObject::GetPort() const +{ + if (m_aPort.isPresent()) + { + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPort.getBegin(); + sal_Unicode const * pEnd = p + m_aPort.getLength(); + sal_uInt32 nThePort; + if (INetMIME::scanUnsigned(p, pEnd, true, nThePort) && p == pEnd) + return nThePort; + } + return 0; +} + +//============================================================================ +bool INetURLObject::SetPort(sal_uInt32 nThePort) +{ + if (getSchemeInfo().m_bPort && m_aHost.isPresent()) + { + UniString aNewPort(UniString::CreateFromInt64(nThePort)); + sal_Int32 nDelta; + if (m_aPort.isPresent()) + nDelta = m_aPort.set(m_aAbsURIRef, aNewPort); + else + { + m_aAbsURIRef.Insert(':', m_aHost.getEnd()); + nDelta = m_aPort.set(m_aAbsURIRef, aNewPort, m_aHost.getEnd() + 1) + + 1; + } + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + return true; + } + return false; +} + +//============================================================================ +void INetURLObject::makePortCanonic() +{ + if (m_aPort.isPresent()) + { + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPort.getBegin(); + sal_Unicode const * pEnd = p + m_aPort.getLength(); + sal_uInt32 nThePort; + if (INetMIME::scanUnsigned(p, pEnd, true, nThePort) && p == pEnd) + { + sal_Int32 nDelta; + if (nThePort != 0 && nThePort == getSchemeInfo().m_nDefaultPort) + { + m_aAbsURIRef.Erase(m_aPort.getBegin() - 1, + m_aPort.getLength() + 1); + nDelta = m_aPort.clear() - 1; + } + else + nDelta = m_aPort.set(m_aAbsURIRef, + UniString::CreateFromInt64(nThePort)); + m_aPath += nDelta; + m_aQuery += nDelta; + m_aFragment += nDelta; + } + } +} + +//============================================================================ +// static +bool INetURLObject::parseHost(sal_Unicode const *& rBegin, + sal_Unicode const * pEnd, bool bOctets, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, UniString & rCanonic) +{ + enum State { STATE_INITIAL, STATE_LABEL, STATE_LABEL_HYPHEN, + STATE_LABEL_DOT, STATE_TOPLABEL, STATE_TOPLABEL_HYPHEN, + STATE_TOPLABEL_DOT, STATE_IP4, STATE_IP4_DOT, STATE_IP6, + STATE_IP6_COLON, STATE_IP6_2COLON, STATE_IP6_3COLON, + STATE_IP6_HEXSEQ1, STATE_IP6_HEXSEQ1_COLON, + STATE_IP6_HEXSEQ1_MAYBE_IP4, STATE_IP6_HEXSEQ2, + STATE_IP6_HEXSEQ2_COLON, STATE_IP6_HEXSEQ2_MAYBE_IP4, + STATE_IP6_IP4, STATE_IP6_IP4_DOT, STATE_IP6_DONE }; + UniString aTheCanonic; + sal_uInt32 nNumber; + int nDigits; + int nOctets; + State eState = STATE_INITIAL; + sal_Unicode const * p = rBegin; + for (; p != pEnd; ++p) + switch (eState) + { + case STATE_INITIAL: + if (*p == '[') + { + aTheCanonic = '['; + eState = STATE_IP6; + } + else if (INetMIME::isAlpha(*p)) + eState = STATE_TOPLABEL; + else if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + nOctets = 1; + eState = STATE_IP4; + } + else + goto done; + break; + + case STATE_LABEL: + if (*p == '.') + eState = STATE_LABEL_DOT; + else if (*p == '-') + eState = STATE_LABEL_HYPHEN; + else if (!INetMIME::isAlphanumeric(*p)) + goto done; + break; + + case STATE_LABEL_HYPHEN: + if (INetMIME::isAlphanumeric(*p)) + eState = STATE_LABEL; + else if (*p != '-') + goto done; + break; + + case STATE_LABEL_DOT: + if (INetMIME::isAlpha(*p)) + eState = STATE_TOPLABEL; + else if (INetMIME::isDigit(*p)) + eState = STATE_LABEL; + else + goto done; + break; + + case STATE_TOPLABEL: + if (*p == '.') + eState = STATE_TOPLABEL_DOT; + else if (*p == '-') + eState = STATE_TOPLABEL_HYPHEN; + else if (!INetMIME::isAlphanumeric(*p)) + goto done; + break; + + case STATE_TOPLABEL_HYPHEN: + if (INetMIME::isAlphanumeric(*p)) + eState = STATE_TOPLABEL; + else if (*p != '-') + goto done; + break; + + case STATE_TOPLABEL_DOT: + if (INetMIME::isAlpha(*p)) + eState = STATE_TOPLABEL; + else if (INetMIME::isDigit(*p)) + eState = STATE_LABEL; + else + goto done; + break; + + case STATE_IP4: + if (*p == '.') + if (nOctets < 4) + { + aTheCanonic += UniString::CreateFromInt32(nNumber); + aTheCanonic += '.'; + ++nOctets; + eState = STATE_IP4_DOT; + } + else + eState = STATE_LABEL_DOT; + else if (*p == '-') + eState = STATE_LABEL_HYPHEN; + else if (INetMIME::isAlpha(*p)) + eState = STATE_LABEL; + else if (INetMIME::isDigit(*p)) + if (nDigits < 3) + { + nNumber = 10 * nNumber + INetMIME::getWeight(*p); + ++nDigits; + } + else + eState = STATE_LABEL; + else + goto done; + break; + + case STATE_IP4_DOT: + if (INetMIME::isAlpha(*p)) + eState = STATE_TOPLABEL; + else if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + eState = STATE_IP4; + } + else + goto done; + break; + + case STATE_IP6: + if (*p == ':') + eState = STATE_IP6_COLON; + else if (INetMIME::isHexDigit(*p)) + { + nNumber = INetMIME::getHexWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ1; + } + else + goto done; + break; + + case STATE_IP6_COLON: + if (*p == ':') + { + aTheCanonic.AppendAscii(RTL_CONSTASCII_STRINGPARAM("::")); + eState = STATE_IP6_2COLON; + } + else + goto done; + break; + + case STATE_IP6_2COLON: + if (*p == ']') + eState = STATE_IP6_DONE; + else if (*p == ':') + { + aTheCanonic += ':'; + eState = STATE_IP6_3COLON; + } + else if (INetMIME::isHexDigit(*p)) + { + nNumber = INetMIME::getHexWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ2; + } + else + goto done; + break; + + case STATE_IP6_3COLON: + if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + nOctets = 1; + eState = STATE_IP6_IP4; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ1: + if (*p == ']') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + eState = STATE_IP6_DONE; + } + else if (*p == ':') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + aTheCanonic += ':'; + eState = STATE_IP6_HEXSEQ1_COLON; + } + else if (INetMIME::isHexDigit(*p) && nDigits < 4) + { + nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); + ++nDigits; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ1_COLON: + if (*p == ':') + { + aTheCanonic.AppendAscii(RTL_CONSTASCII_STRINGPARAM("::")); + eState = STATE_IP6_2COLON; + } + else if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ1_MAYBE_IP4; + } + else if (INetMIME::isHexDigit(*p)) + { + nNumber = INetMIME::getHexWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ1; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ1_MAYBE_IP4: + if (*p == ']') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + eState = STATE_IP6_DONE; + } + else if (*p == ':') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + aTheCanonic += ':'; + eState = STATE_IP6_HEXSEQ1_COLON; + } + else if (*p == '.') + { + nNumber = 100 * (nNumber >> 8) + 10 * (nNumber >> 4 & 15) + + (nNumber & 15); + aTheCanonic += UniString::CreateFromInt32(nNumber); + aTheCanonic += '.'; + nOctets = 2; + eState = STATE_IP6_IP4_DOT; + } + else if (INetMIME::isDigit(*p) && nDigits < 3) + { + nNumber = 16 * nNumber + INetMIME::getWeight(*p); + ++nDigits; + } + else if (INetMIME::isHexDigit(*p) && nDigits < 4) + { + nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); + ++nDigits; + eState = STATE_IP6_HEXSEQ1; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ2: + if (*p == ']') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + eState = STATE_IP6_DONE; + } + else if (*p == ':') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + aTheCanonic += ':'; + eState = STATE_IP6_HEXSEQ2_COLON; + } + else if (INetMIME::isHexDigit(*p) && nDigits < 4) + { + nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); + ++nDigits; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ2_COLON: + if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ2_MAYBE_IP4; + } + else if (INetMIME::isHexDigit(*p)) + { + nNumber = INetMIME::getHexWeight(*p); + nDigits = 1; + eState = STATE_IP6_HEXSEQ2; + } + else + goto done; + break; + + case STATE_IP6_HEXSEQ2_MAYBE_IP4: + if (*p == ']') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + eState = STATE_IP6_DONE; + } + else if (*p == ':') + { + aTheCanonic += UniString::CreateFromInt32(nNumber, 16); + aTheCanonic += ':'; + eState = STATE_IP6_HEXSEQ2_COLON; + } + else if (*p == '.') + { + nNumber = 100 * (nNumber >> 8) + 10 * (nNumber >> 4 & 15) + + (nNumber & 15); + aTheCanonic += UniString::CreateFromInt32(nNumber); + aTheCanonic += '.'; + nOctets = 2; + eState = STATE_IP6_IP4_DOT; + } + else if (INetMIME::isDigit(*p) && nDigits < 3) + { + nNumber = 16 * nNumber + INetMIME::getWeight(*p); + ++nDigits; + } + else if (INetMIME::isHexDigit(*p) && nDigits < 4) + { + nNumber = 16 * nNumber + INetMIME::getHexWeight(*p); + ++nDigits; + eState = STATE_IP6_HEXSEQ2; + } + else + goto done; + break; + + case STATE_IP6_IP4: + if (*p == ']') + if (nOctets == 4) + { + aTheCanonic += UniString::CreateFromInt32(nNumber); + eState = STATE_IP6_DONE; + } + else + goto done; + else if (*p == '.') + if (nOctets < 4) + { + aTheCanonic += UniString::CreateFromInt32(nNumber); + aTheCanonic += '.'; + ++nOctets; + eState = STATE_IP6_IP4_DOT; + } + else + goto done; + else if (INetMIME::isDigit(*p) && nDigits < 3) + { + nNumber = 10 * nNumber + INetMIME::getWeight(*p); + ++nDigits; + } + else + goto done; + break; + + case STATE_IP6_IP4_DOT: + if (INetMIME::isDigit(*p)) + { + nNumber = INetMIME::getWeight(*p); + nDigits = 1; + eState = STATE_IP6_IP4; + } + else + goto done; + break; + } + done: + switch (eState) + { + case STATE_LABEL: + case STATE_TOPLABEL: + case STATE_TOPLABEL_DOT: + aTheCanonic.Assign(rBegin, p - rBegin); + rBegin = p; + rCanonic = aTheCanonic; + return true; + + case STATE_IP4: + if (nOctets == 4) + { + aTheCanonic += UniString::CreateFromInt32(nNumber); + rBegin = p; + rCanonic = aTheCanonic; + return true; + } + break; + + case STATE_IP6_DONE: + aTheCanonic += ']'; + rBegin = p; + rCanonic = aTheCanonic; + return true; + } + return false; +} + +//============================================================================ +sal_Int32 INetURLObject::getSegmentCount(bool bIgnoreFinalSlash) const +{ + if (!getSchemeInfo().m_bHierarchical) + return 0; + + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pEnd = p + m_aPath.getLength(); + if (p == pEnd || *p != '/') + return 0; + + if (bIgnoreFinalSlash && pEnd[-1] == '/') + --pEnd; + + sal_Int32 n = 0; + while (p != pEnd) + if (*p++ == '/') + ++n; + return n; +} + +//============================================================================ +bool INetURLObject::removeSegment(sal_Int32 nIndex, bool bIgnoreFinalSlash) +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + UniString aNewPath(m_aAbsURIRef, m_aPath.getBegin(), + aSegment.getBegin() - m_aPath.getBegin()); + if (bIgnoreFinalSlash && aSegment.getEnd() == m_aPath.getEnd()) + aNewPath += '/'; + else + aNewPath.Append(m_aAbsURIRef.GetBuffer() + aSegment.getEnd(), + m_aPath.getEnd() - aSegment.getEnd()); + if (aNewPath.Len() == 0) + aNewPath = '/'; + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +UniString INetURLObject::getName(sal_Int32 nIndex, bool bIgnoreFinalSlash, + DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return UniString(); + + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * p = pSegBegin; + while (p != pSegEnd && *p != ';') + ++p; + + return decode(pSegBegin, p, getEscapePrefix(), eMechanism, eCharset); +} + +//============================================================================ +bool INetURLObject::setName(UniString const & rTheName, sal_Int32 nIndex, + bool bIgnoreFinalSlash, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * p = pSegBegin; + while (p != pSegEnd && *p != ';') + ++p; + + UniString aNewPath(pPathBegin, pSegBegin - pPathBegin); + aNewPath += encodeText(rTheName, false, PART_PCHAR, getEscapePrefix(), + eMechanism, eCharset, true); + aNewPath.Append(p, pPathEnd - p); + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +bool INetURLObject::hasExtension(sal_Int32 nIndex, bool bIgnoreFinalSlash) + const +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + for (sal_Unicode const * p = pSegBegin; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + return true; + return false; +} + +//============================================================================ +UniString INetURLObject::getBase(sal_Int32 nIndex, bool bIgnoreFinalSlash, + DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return UniString(); + + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * pExtension = 0; + sal_Unicode const * p = pSegBegin; + for (; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + pExtension = p; + if (!pExtension) + pExtension = p; + + return decode(pSegBegin, pExtension, getEscapePrefix(), eMechanism, + eCharset); +} + +//============================================================================ +bool INetURLObject::setBase(UniString const & rTheBase, sal_Int32 nIndex, + bool bIgnoreFinalSlash, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * pExtension = 0; + sal_Unicode const * p = pSegBegin; + for (; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + pExtension = p; + if (!pExtension) + pExtension = p; + + UniString aNewPath(pPathBegin, pSegBegin - pPathBegin); + aNewPath += encodeText(rTheBase, false, PART_PCHAR, getEscapePrefix(), + eMechanism, eCharset, true); + aNewPath.Append(pExtension, pPathEnd - pExtension); + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +UniString INetURLObject::getExtension(sal_Int32 nIndex, + bool bIgnoreFinalSlash, + DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return UniString(); + + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * pExtension = 0; + sal_Unicode const * p = pSegBegin; + for (; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + pExtension = p; + + if (!pExtension) + return UniString(); + + return decode(pExtension + 1, p, getEscapePrefix(), eMechanism, eCharset); +} + +//============================================================================ +bool INetURLObject::setExtension(UniString const & rTheExtension, + sal_Int32 nIndex, bool bIgnoreFinalSlash, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * pExtension = 0; + sal_Unicode const * p = pSegBegin; + for (; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + pExtension = p; + if (!pExtension) + pExtension = p; + + UniString aNewPath(pPathBegin, pExtension - pPathBegin); + aNewPath += '.'; + aNewPath += encodeText(rTheExtension, false, PART_PCHAR, + getEscapePrefix(), eMechanism, eCharset, true); + aNewPath.Append(p, pPathEnd - p); + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +bool INetURLObject::removeExtension(sal_Int32 nIndex, bool bIgnoreFinalSlash) +{ + SubString aSegment(getSegment(nIndex, bIgnoreFinalSlash)); + if (!aSegment.isPresent()) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + sal_Unicode const * pSegBegin + = m_aAbsURIRef.GetBuffer() + aSegment.getBegin(); + sal_Unicode const * pSegEnd = pSegBegin + aSegment.getLength(); + + ++pSegBegin; + sal_Unicode const * pExtension = 0; + sal_Unicode const * p = pSegBegin; + for (; p != pSegEnd && *p != ';'; ++p) + if (*p == '.' && p != pSegBegin) + pExtension = p; + if (!pExtension) + return true; + + UniString aNewPath(pPathBegin, pExtension - pPathBegin); + aNewPath.Append(p, pPathEnd - p); + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +bool INetURLObject::hasFinalSlash() const +{ + if (!getSchemeInfo().m_bHierarchical) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + if (pPathBegin == pPathEnd || *pPathBegin != '/') + return false; + + return pPathEnd[-1] == '/'; +} + +//============================================================================ +bool INetURLObject::setFinalSlash() +{ + if (!getSchemeInfo().m_bHierarchical) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + if (pPathBegin == pPathEnd || *pPathBegin != '/') + return false; + + if (pPathEnd[-1] == '/') + return true; + + UniString aNewPath(pPathBegin, pPathEnd - pPathBegin); + aNewPath += '/'; + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +bool INetURLObject::removeFinalSlash() +{ + if (!getSchemeInfo().m_bHierarchical) + return false; + + sal_Unicode const * pPathBegin + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pPathEnd = pPathBegin + m_aPath.getLength(); + if (pPathBegin == pPathEnd || *pPathBegin != '/') + return false; + + if (pPathEnd[-1] != '/') + return true; + + --pPathEnd; + if (pPathEnd == pPathBegin) + return false; + UniString aNewPath(pPathBegin, pPathEnd - pPathBegin); + + return setPath(aNewPath, false, NOT_CANONIC, RTL_TEXTENCODING_UTF8); +} + +//============================================================================ +// static +UniString INetURLObject::createFragment(UniString const & rText) +{ + UniString aFragment(rText); + for (xub_StrLen i = 0; i < aFragment.Len();) + { + sal_Unicode c = aFragment.GetChar(i); + if (mustEncode(aFragment.GetChar(i), PART_CREATEFRAGMENT)) + aFragment.Erase(i, 1); + else + ++i; + } + return aFragment; +} + +//============================================================================ +bool INetURLObject::setFSysPath(UniString const & rFSysPath, FSysStyle eStyle) +{ + sal_Unicode const * pFSysBegin = rFSysPath.GetBuffer(); + sal_Unicode const * pFSysEnd = pFSysBegin + rFSysPath.Len(); + + switch ((eStyle & FSYS_VOS ? 1 : 0) + + (eStyle & FSYS_UNX ? 1 : 0) + + (eStyle & FSYS_DOS ? 1 : 0) + + (eStyle & FSYS_MAC ? 1 : 0)) + { + case 0: + return false; + + case 1: + break; + + default: + if (eStyle & FSYS_VOS + && pFSysEnd - pFSysBegin >= 2 + && pFSysBegin[0] == '/' + && pFSysBegin[1] == '/') + { + if (pFSysEnd - pFSysBegin >= 3 + && pFSysBegin[2] == '.' + && (pFSysEnd - pFSysBegin == 3 || pFSysBegin[3] == '/')) + { + eStyle = FSYS_VOS; // Production T1 + break; + } + + sal_Unicode const * p = pFSysBegin + 2; + UniString aHost; + if (parseHost(p, pFSysEnd, false, ENCODE_ALL, + RTL_TEXTENCODING_UTF8, aHost) + && (p == pFSysEnd || *p == '/')) + { + eStyle = FSYS_VOS; // Production T2 + break; + } + } + + if (eStyle & FSYS_DOS + && pFSysEnd - pFSysBegin >= 2 + && pFSysBegin[0] == '\\' + && pFSysBegin[1] == '\\') + { + sal_Unicode const * p = pFSysBegin + 2; + UniString aHost; + if (parseHost(p, pFSysEnd, false, ENCODE_ALL, + RTL_TEXTENCODING_UTF8, aHost) + && (p == pFSysEnd || *p == '\\')) + { + eStyle = FSYS_DOS; // Production T3 + break; + } + } + + if (eStyle & FSYS_DOS + && pFSysEnd - pFSysBegin >= 3 + && INetMIME::isAlpha(pFSysBegin[0]) + && pFSysBegin[1] == ':' + && (pFSysBegin[2] == '/' || pFSysBegin[2] == '\\')) + { + eStyle = FSYS_DOS; // Productions T4, T5 + break; + } + + if (!(eStyle & (FSYS_UNX | FSYS_DOS | FSYS_MAC))) + return false; + + eStyle = guessFSysStyleByCounting(pFSysBegin, pFSysEnd, eStyle); + // Production T6 + break; + } + + UniString aSynAbsURIRef(RTL_CONSTASCII_USTRINGPARAM("file://")); + switch (eStyle) + { + case FSYS_VOS: + { + sal_Unicode const * p = pFSysBegin; + if (pFSysEnd - p < 2 || *p++ != '/' || *p++ != '/') + return false; + if (p != pFSysEnd && *p == '.' + && (pFSysEnd - p == 1 || p[1] == '/')) + ++p; + for (; p != pFSysEnd; ++p) + switch (*p) + { + case '#': + case '%': + appendEscape(aSynAbsURIRef, '%', *p); + break; + + default: + aSynAbsURIRef += *p; + break; + } + break; + } + + case FSYS_UNX: + { + sal_Unicode const * p = pFSysBegin; + if (p != pFSysEnd && *p != '/') + return false; + for (; p != pFSysEnd; ++p) + switch (*p) + { + case '|': + case '#': + case '%': + appendEscape(aSynAbsURIRef, '%', *p); + break; + + default: + aSynAbsURIRef += *p; + break; + } + break; + } + + case FSYS_DOS: + { + sal_uInt32 nAltDelimiter = 0x80000000; + sal_Unicode const * p = pFSysBegin; + if (pFSysEnd - p >= 3 && p[0] == '\\' && p[1] == '\\') + p += 2; + else + { + aSynAbsURIRef += '/'; + if (pFSysEnd - p >= 3 && INetMIME::isAlpha(p[0]) + && p[1] == ':' && (p[2] == '\\' || p[2] == '/')) + nAltDelimiter = '/'; + } + for (; p != pFSysEnd; ++p) + if (*p == '\\' || *p == nAltDelimiter) + aSynAbsURIRef += '/'; + else + switch (*p) + { + case '/': + case '#': + case '%': + appendEscape(aSynAbsURIRef, '%', *p); + break; + + default: + aSynAbsURIRef += *p; + break; + } + break; + } + + case FSYS_MAC: + aSynAbsURIRef += '/'; + {for (sal_Unicode const * p = pFSysBegin; p != pFSysEnd; ++p) + switch (*p) + { + case ':': + aSynAbsURIRef += '/'; + break; + + case '/': + case '|': + case '#': + case '%': + appendEscape(aSynAbsURIRef, '%', *p); + break; + + default: + aSynAbsURIRef += *p; + break; + } + } + break; + } + + INetURLObject aTemp(aSynAbsURIRef, WAS_ENCODED, RTL_TEXTENCODING_UTF8); + if (aTemp.HasError()) + return false; + + *this = aTemp; + return true; +} + +//============================================================================ +UniString INetURLObject::getFSysPath(FSysStyle eStyle, + sal_Unicode * pDelimiter) const +{ + if (m_eScheme != INET_PROT_FILE) + return UniString(); + + if ((eStyle & FSYS_VOS ? 1 : 0) + + (eStyle & FSYS_UNX ? 1 : 0) + + (eStyle & FSYS_DOS ? 1 : 0) + + (eStyle & FSYS_MAC ? 1 : 0) + > 1) + { + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + eStyle = eStyle & FSYS_VOS + && m_aHost.isPresent() + && m_aHost.getLength() > 0 ? + FSYS_VOS : + eStyle & FSYS_DOS + && (!m_aHost.isPresent() || m_aHost.getLength() == 0) + && m_aPath.getLength() >= 3 + && p[0] == '/' + && INetMIME::isAlpha(p[1]) + && p[2] == ':' + && (m_aPath.getLength() == 3 || p[3] == '/') ? + FSYS_DOS : + eStyle & FSYS_UNX + && (!m_aHost.isPresent() || m_aHost.getLength() == 0) ? + FSYS_UNX : + FSysStyle(0); + } + + switch (eStyle) + { + case FSYS_VOS: + { + if (pDelimiter) + *pDelimiter = '/'; + + UniString aSynFSysPath(RTL_CONSTASCII_USTRINGPARAM("//")); + if (m_aHost.isPresent() && m_aHost.getLength() > 0) + aSynFSysPath += decode(m_aHost, '%', DECODE_WITH_CHARSET, + RTL_TEXTENCODING_UTF8); + else + aSynFSysPath += '.'; + aSynFSysPath += decode(m_aPath, '%', DECODE_WITH_CHARSET, + RTL_TEXTENCODING_UTF8); + return aSynFSysPath; + } + + case FSYS_UNX: + { + if (m_aHost.isPresent() && m_aHost.getLength() > 0) + return UniString(); + + if (pDelimiter) + *pDelimiter = '/'; + + return decode(m_aPath, '%', DECODE_WITH_CHARSET, + RTL_TEXTENCODING_UTF8); + } + + case FSYS_DOS: + { + if (pDelimiter) + *pDelimiter = '\\'; + + UniString aSynFSysPath; + if (m_aHost.isPresent() && m_aHost.getLength() > 0) + { + aSynFSysPath.AssignAscii(RTL_CONSTASCII_STRINGPARAM("\\\\")); + aSynFSysPath += decode(m_aHost, '%', DECODE_WITH_CHARSET, + RTL_TEXTENCODING_UTF8); + aSynFSysPath += '\\'; + } + sal_Unicode const * p + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pEnd = p + m_aPath.getLength(); + DBG_ASSERT(p < pEnd && *p == '/', + "INetURLObject::getFSysPath(): Bad path"); + ++p; + while (p < pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(p, pEnd, false, '%', WAS_ENCODED, + RTL_TEXTENCODING_UTF8, + eEscapeType); + if (eEscapeType == ESCAPE_NO && nUTF32 == '/') + aSynFSysPath += '\\'; + else + appendUTF32(aSynFSysPath, nUTF32); + } + return aSynFSysPath; + } + + case FSYS_MAC: + { + if (m_aHost.isPresent() && m_aHost.getLength() > 0) + return UniString(); + + if (pDelimiter) + *pDelimiter = ':'; + + UniString aSynFSysPath; + sal_Unicode const * p + = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pEnd = p + m_aPath.getLength(); + DBG_ASSERT(p < pEnd && *p == '/', + "INetURLObject::getFSysPath(): Bad path"); + ++p; + while (p < pEnd) + { + EscapeType eEscapeType; + sal_uInt32 nUTF32 = getUTF32(p, pEnd, false, '%', WAS_ENCODED, + RTL_TEXTENCODING_UTF8, + eEscapeType); + if (eEscapeType == ESCAPE_NO && nUTF32 == '/') + aSynFSysPath += ':'; + else + appendUTF32(aSynFSysPath, nUTF32); + } + return aSynFSysPath; + } + } + + return UniString(); +} + +//============================================================================ +bool INetURLObject::HasMsgId() const +{ + if (m_eScheme != INET_PROT_NEWS && m_eScheme != INET_PROT_POP3) + return false; + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pEnd = p + m_aPath.getLength(); + for (; p < pEnd; ++p) + if (*p == '<') + return true; + return false; +} + +//============================================================================ +UniString INetURLObject::GetMsgId(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + if (m_eScheme != INET_PROT_NEWS && m_eScheme != INET_PROT_POP3) + return UniString(); + sal_Unicode const * p = m_aAbsURIRef.GetBuffer() + m_aPath.getBegin(); + sal_Unicode const * pEnd = p + m_aPath.getLength(); + for (; p < pEnd; ++p) + if (*p == '<') + return decode(p, pEnd, getEscapePrefix(), eMechanism, eCharset); + return UniString(); +} + +//============================================================================ +// static +void INetURLObject::appendUCS4Escape(UniString & rTheText, + sal_Char cEscapePrefix, sal_uInt32 nUCS4) +{ + DBG_ASSERT(nUCS4 < 0x80000000, + "INetURLObject::appendUCS4Escape(): Bad char"); + if (nUCS4 < 0x80) + appendEscape(rTheText, cEscapePrefix, nUCS4); + else if (nUCS4 < 0x800) + { + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 | 0xC0); + appendEscape(rTheText, cEscapePrefix, nUCS4 & 0x3F | 0x80); + } + else if (nUCS4 < 0x10000) + { + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 12 | 0xE0); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 & 0x3F | 0x80); + } + else if (nUCS4 < 0x200000) + { + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 18 | 0xF0); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 12 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 & 0x3F | 0x80); + } + else if (nUCS4 < 0x4000000) + { + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 24 | 0xF8); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 18 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 12 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 & 0x3F | 0x80); + } + else + { + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 30 | 0xFC); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 24 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 18 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 12 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 >> 6 & 0x3F | 0x80); + appendEscape(rTheText, cEscapePrefix, nUCS4 & 0x3F | 0x80); + } +} + +//============================================================================ +// static +void INetURLObject::appendUCS4(UniString & rTheText, sal_uInt32 nUCS4, + EscapeType eEscapeType, bool bOctets, + Part ePart, sal_Char cEscapePrefix, + rtl_TextEncoding eCharset, + bool bKeepVisibleEscapes) +{ + bool bEscape; + rtl_TextEncoding eTargetCharset; + switch (eEscapeType) + { + case ESCAPE_NO: + if (mustEncode(nUCS4, ePart)) + { + bEscape = true; + eTargetCharset = bOctets ? RTL_TEXTENCODING_ISO_8859_1 : + RTL_TEXTENCODING_UTF8; + } + else + bEscape = false; + break; + + case ESCAPE_OCTET: + bEscape = true; + eTargetCharset = RTL_TEXTENCODING_ISO_8859_1; + break; + + case ESCAPE_UTF32: + if (mustEncode(nUCS4, ePart)) + { + bEscape = true; + eTargetCharset = eCharset; + } + else if (bKeepVisibleEscapes && INetMIME::isVisible(nUCS4)) + { + bEscape = true; + eTargetCharset = RTL_TEXTENCODING_ASCII_US; + } + else + bEscape = false; + break; + } + if (bEscape) + switch (eTargetCharset) + { + default: + DBG_ERROR("INetURLObject::appendUCS4(): Unsupported charset"); + case RTL_TEXTENCODING_ASCII_US: + case RTL_TEXTENCODING_ISO_8859_1: + appendEscape(rTheText, cEscapePrefix, nUCS4); + break; + + case RTL_TEXTENCODING_UTF8: + appendUCS4Escape(rTheText, cEscapePrefix, nUCS4); + break; + } + else + rTheText += sal_Unicode(nUCS4); +} + +//============================================================================ +// static +sal_uInt32 INetURLObject::getUTF32(sal_Unicode const *& rBegin, + sal_Unicode const * pEnd, bool bOctets, + sal_Char cEscapePrefix, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset, + EscapeType & rEscapeType) +{ + DBG_ASSERT(rBegin < pEnd, "INetURLObject::getUTF32(): Bad sequence"); + sal_uInt32 nUTF32 = bOctets ? *rBegin++ : + INetMIME::getUTF32Character(rBegin, pEnd); + switch (eMechanism) + { + case ENCODE_ALL: + rEscapeType = ESCAPE_NO; + break; + + case WAS_ENCODED: + { + int nWeight1; + int nWeight2; + if (nUTF32 == cEscapePrefix && rBegin + 1 < pEnd + && (nWeight1 = INetMIME::getHexWeight(rBegin[0])) >= 0 + && (nWeight2 = INetMIME::getHexWeight(rBegin[1])) >= 0) + { + rBegin += 2; + nUTF32 = nWeight1 << 4 | nWeight2; + switch (eCharset) + { + default: + DBG_ERROR( + "INetURLObject::getUTF32(): Unsupported charset"); + case RTL_TEXTENCODING_ASCII_US: + rEscapeType = INetMIME::isUSASCII(nUTF32) ? + ESCAPE_UTF32 : ESCAPE_OCTET; + break; + + case RTL_TEXTENCODING_ISO_8859_1: + rEscapeType = ESCAPE_UTF32; + break; + + case RTL_TEXTENCODING_UTF8: + if (INetMIME::isUSASCII(nUTF32)) + rEscapeType = ESCAPE_UTF32; + else + { + if (nUTF32 >= 0xC0 && nUTF32 <= 0xF4) + { + sal_uInt32 nEncoded; + int nShift; + sal_uInt32 nMin; + if (nUTF32 <= 0xDF) + { + nEncoded = (nUTF32 & 0x1F) << 6; + nShift = 0; + nMin = 0x80; + } + else if (nUTF32 <= 0xEF) + { + nEncoded = (nUTF32 & 0x0F) << 12; + nShift = 6; + nMin = 0x800; + } + else + { + nEncoded = (nUTF32 & 0x07) << 18; + nShift = 12; + nMin = 0x10000; + } + sal_Unicode const * p = rBegin; + bool bUTF8 = true; + for (;;) + { + if (pEnd - p < 3 + || p[0] != cEscapePrefix + || (nWeight1 + = INetMIME::getHexWeight(p[1])) + < 8 + || nWeight1 > 11 + || (nWeight2 + = INetMIME::getHexWeight(p[2])) + < 0) + { + bUTF8 = false; + break; + } + p += 3; + nEncoded + |= ((nWeight1 & 3) << 4 | nWeight2) + << nShift; + if (nShift == 0) + break; + nShift -= 6; + } + if (bUTF8 && nEncoded >= nMin + && !INetMIME::isHighSurrogate(nEncoded) + && !INetMIME::isLowSurrogate(nEncoded) + && nEncoded <= 0x10FFFF) + { + rBegin = p; + nUTF32 = nEncoded; + rEscapeType = ESCAPE_UTF32; + break; + } + } + rEscapeType = ESCAPE_OCTET; + } + break; + } + } + else + rEscapeType = ESCAPE_NO; + break; + } + + case NOT_CANONIC: + { + int nWeight1; + int nWeight2; + if (nUTF32 == cEscapePrefix && rBegin + 1 < pEnd + && ((nWeight1 = INetMIME::getHexWeight(rBegin[0])) >= 0) + && ((nWeight2 = INetMIME::getHexWeight(rBegin[1])) >= 0)) + { + rBegin += 2; + nUTF32 = nWeight1 << 4 | nWeight2; + rEscapeType = ESCAPE_OCTET; + } + else + rEscapeType = ESCAPE_NO; + break; + } + } + return nUTF32; +} + +//============================================================================ +// static +sal_uInt32 INetURLObject::scanDomain(sal_Unicode const *& rBegin, + sal_Unicode const * pEnd, + bool bEager) +{ + enum State { STATE_DOT, STATE_LABEL, STATE_HYPHEN }; + State eState = STATE_DOT; + xub_StrLen nLabels = 0; + sal_Unicode const * pLastAlphanumeric = 0; + for (sal_Unicode const * p = rBegin;; ++p) + switch (eState) + { + case STATE_DOT: + if (p != pEnd && INetMIME::isAlphanumeric(*p)) + { + ++nLabels; + eState = STATE_LABEL; + break; + } + if (bEager || nLabels == 0) + return 0; + rBegin = p - 1; + return nLabels; + + case STATE_LABEL: + if (p != pEnd) + if (INetMIME::isAlphanumeric(*p)) + break; + else if (*p == '.') + { + eState = STATE_DOT; + break; + } + else if (*p == '-') + { + pLastAlphanumeric = p; + eState = STATE_HYPHEN; + break; + } + rBegin = p; + return nLabels; + + case STATE_HYPHEN: + if (p != pEnd) + if (INetMIME::isAlphanumeric(*p)) + { + eState = STATE_LABEL; + break; + } + else if (*p == '-') + break; + if (bEager) + return 0; + rBegin = pLastAlphanumeric; + return nLabels; + } +} + +//============================================================================ +// static +bool INetURLObject::scanIPv6reference(sal_Unicode const *& rBegin, + sal_Unicode const * pEnd, + bool bEager) +{ + return false; //@@@ +} + +//============================================================================ +// static +UniString INetURLObject::RelToAbs(ByteString const & rTheRelURIRef, + bool bIgnoreFragment, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset, + FSysStyle eStyle) +{ + // Backwards compatibility: + if (rTheRelURIRef.Len() == 0 || rTheRelURIRef.GetChar(0) == '#') + return extend(rTheRelURIRef); + + INetURLObject aTheAbsURIRef; + bool bWasAbsolute; + m_aBaseURIRef.convertRelToAbs(extend(rTheRelURIRef), true, aTheAbsURIRef, + bWasAbsolute, eEncodeMechanism, eCharset, + bIgnoreFragment, false, false, eStyle); + return aTheAbsURIRef.GetMainURL(eDecodeMechanism, eCharset); +} + +//============================================================================ +// static +UniString INetURLObject::RelToAbs(UniString const & rTheRelURIRef, + bool bIgnoreFragment, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset, + FSysStyle eStyle) +{ + // Backwards compatibility: + if (rTheRelURIRef.Len() == 0 || rTheRelURIRef.GetChar(0) == '#') + return rTheRelURIRef; + + INetURLObject aTheAbsURIRef; + bool bWasAbsolute; + return m_aBaseURIRef.convertRelToAbs(rTheRelURIRef, false, aTheAbsURIRef, + bWasAbsolute, eEncodeMechanism, + eCharset, bIgnoreFragment, false, + false, eStyle) + || eEncodeMechanism != WAS_ENCODED + || eDecodeMechanism != DECODE_TO_IURI + || eCharset != RTL_TEXTENCODING_UTF8 ? + aTheAbsURIRef.GetMainURL(eDecodeMechanism, eCharset) : + rTheRelURIRef; +} + +//============================================================================ +// static +UniString INetURLObject::AbsToRel(ByteString const & rTheAbsURIRef, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset, + FSysStyle eStyle) +{ + UniString aTheRelURIRef; + m_aBaseURIRef.convertAbsToRel(extend(rTheAbsURIRef), true, aTheRelURIRef, + eEncodeMechanism, eDecodeMechanism, + eCharset, eStyle); + return aTheRelURIRef; +} + +//============================================================================ +// static +UniString INetURLObject::AbsToRel(UniString const & rTheAbsURIRef, + EncodeMechanism eEncodeMechanism, + DecodeMechanism eDecodeMechanism, + rtl_TextEncoding eCharset, + FSysStyle eStyle) +{ + UniString aTheRelURIRef; + m_aBaseURIRef.convertAbsToRel(rTheAbsURIRef, false, aTheRelURIRef, + eEncodeMechanism, eDecodeMechanism, + eCharset, eStyle); + return aTheRelURIRef; +} + +//============================================================================ +// static +bool INetURLObject::SetBaseURL(ByteString const & rTheBaseURIRef, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + return m_aBaseURIRef.SetURL(rTheBaseURIRef, eMechanism, eCharset); +} + +//============================================================================ +// static +bool INetURLObject::SetBaseURL(UniString const & rTheBaseURIRef, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + return m_aBaseURIRef.SetURL(rTheBaseURIRef, eMechanism, eCharset); +} + +//============================================================================ +// static +UniString INetURLObject::GetBaseURL(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + return m_aBaseURIRef.GetMainURL(eMechanism, eCharset); +} + +//============================================================================ +UniString INetURLObject::GetPartBeforeLastName(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) + const +{ + if (!getSchemeInfo().m_bHierarchical) + return UniString(); + INetURLObject aTemp(*this); + aTemp.clearFragment(); + aTemp.clearQuery(); + aTemp.removeSegment(LAST_SEGMENT, false); + aTemp.setFinalSlash(); + return aTemp.GetMainURL(eMechanism, eCharset); +} + +//============================================================================ +UniString INetURLObject::GetLastName(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + return getName(LAST_SEGMENT, true, eMechanism, eCharset); +} + +//============================================================================ +UniString INetURLObject::GetFileExtension(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) const +{ + return getExtension(LAST_SEGMENT, false, eMechanism, eCharset); +} + +//============================================================================ +bool INetURLObject::CutLastName() +{ + INetURLObject aTemp(*this); + aTemp.clearFragment(); + aTemp.clearQuery(); + if (!aTemp.removeSegment(LAST_SEGMENT, false)) + return false; + *this = aTemp; + return true; +} + +//============================================================================ +UniString INetURLObject::PathToFileName() const +{ + if (m_eScheme != INET_PROT_FILE) + return UniString(); + rtl::OUString aNormalizedPath; + if (osl::FileBase::getNormalizedPathFromFileURL( + decode(m_aAbsURIRef.GetBuffer(), + m_aAbsURIRef.GetBuffer() + m_aPath.getEnd(), + getEscapePrefix(), NO_DECODE, RTL_TEXTENCODING_UTF8), + aNormalizedPath) + != osl::FileBase::E_None) + return UniString(); + rtl::OUString aSystemPath; + if (osl::FileBase::getSystemPathFromNormalizedPath(aNormalizedPath, + aSystemPath) + != osl::FileBase::E_None) + return UniString(); + return aSystemPath; +} + +//============================================================================ +UniString INetURLObject::GetFull() const +{ + INetURLObject aTemp(*this); + aTemp.removeFinalSlash(); + return aTemp.PathToFileName(); +} + +//============================================================================ +UniString INetURLObject::GetPath() const +{ + INetURLObject aTemp(*this); + aTemp.removeSegment(LAST_SEGMENT, true); + aTemp.removeFinalSlash(); + return aTemp.PathToFileName(); +} + +//============================================================================ +void INetURLObject::SetBase(UniString const & rTheBase) +{ + setBase(rTheBase, LAST_SEGMENT, true, ENCODE_ALL); +} + +//============================================================================ +UniString INetURLObject::GetBase() const +{ + return getBase(LAST_SEGMENT, true, DECODE_WITH_CHARSET); +} + +//============================================================================ +void INetURLObject::SetName(UniString const & rTheName, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + INetURLObject aTemp(*this); + if (aTemp.removeSegment(LAST_SEGMENT, true) + && aTemp.insertName(rTheName, false, LAST_SEGMENT, true, eMechanism, + eCharset)) + *this = aTemp; +} + +//============================================================================ +UniString INetURLObject::CutName(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + UniString aTheName(getName(LAST_SEGMENT, true, eMechanism, eCharset)); + return removeSegment(LAST_SEGMENT, true) ? aTheName : UniString(); +} + +//============================================================================ +void INetURLObject::SetExtension(UniString const & rTheExtension, + EncodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + setExtension(rTheExtension, LAST_SEGMENT, false, eMechanism, eCharset); +} + +//============================================================================ +UniString INetURLObject::CutExtension(DecodeMechanism eMechanism, + rtl_TextEncoding eCharset) +{ + UniString aTheExtension(getExtension(LAST_SEGMENT, false, eMechanism, + eCharset)); + return removeExtension(LAST_SEGMENT, false) ? aTheExtension : UniString(); +} + +//============================================================================ +bool INetURLObject::IsCaseSensitive() const +{ + return true; +} diff --git a/tools/source/fsys/wldcrd.cxx b/tools/source/fsys/wldcrd.cxx new file mode 100644 index 000000000000..8b8bd7c5950b --- /dev/null +++ b/tools/source/fsys/wldcrd.cxx @@ -0,0 +1,177 @@ +/************************************************************************* + * + * $RCSfile: wldcrd.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _WLDCRD_HXX +#include <wldcrd.hxx> +#endif + +/************************************************************************* +|* +|* WildCard::Match() +|* +|* Beschreibung WLDCRD.SDW +|* Ersterstellung MA 19.06.91 +|* Letzte Aenderung MA 03.07.91 +|* +*************************************************************************/ + +/* Diese Methode ueberprueft, ob die Wilde Karte in pWild mit dem String + * in pStr matscht. + * Vertragen sich die beiden, so wird 1 zurueckgegeben, sonst 0. + * + * ein '*' in pWild bedeutet n beliebige Zeichen, mit n>=0 + * ein '?' in pWild bedeutet genau ein beliebiges Zeichen + * + */ + +USHORT WildCard::ImpMatch( const char *pWild, const char *pStr ) const +{ + int pos=0; + int flag=0; + + while ( *pWild || flag ) + { + switch (*pWild) + { + case '?': + if ( *pStr == '\0' ) + return 0; + break; + + default: + if ( (*pWild == '\\') && ((*(pWild+1)=='?') || (*(pWild+1) == '*')) ) + pWild++; + if ( *pWild != *pStr ) + if ( !pos ) + return 0; + else + pWild += pos; + else + break; // ACHTUNG laeuft unter bestimmten + // Umstaenden in den nachsten case rein!! + case '*': + while ( *pWild == '*' ) + pWild++; + if ( *pWild == '\0' ) + return 1; + flag = 1; + pos = 0; + if ( *pStr == '\0' ) + return ( *pWild == '\0' ); + while ( *pStr && *pStr != *pWild ) + { + if ( *pWild == '?' ) { + pWild++; + while ( *pWild == '*' ) + pWild++; + } + pStr++; + if ( *pStr == '\0' ) + return ( *pWild == '\0' ); + } + break; + } + if ( *pWild != '\0' ) + pWild++; + if ( *pStr != '\0' ) + pStr++; + else + flag = 0; + if ( flag ) + pos--; + } + return ( *pStr == '\0' ) && ( *pWild == '\0' ); +} + +/************************************************************************* +|* +|* WildCard::Matches() +|* +|* Beschreibung WLDCRD.SDW +|* Ersterstellung MA 19.06.91 +|* Letzte Aenderung TH 02.02.96 +|* +*************************************************************************/ + +BOOL WildCard::Matches( const String& rString ) const +{ + ByteString aTmpWild = aWildString; + ByteString aString(rString, osl_getThreadTextEncoding()); + + USHORT nSepPos; + + if ( cSepSymbol != '\0' ) + { + while ( (nSepPos = aTmpWild.Search( cSepSymbol )) != STRING_NOTFOUND ) + { + // alle getrennten WildCard's pruefen + if ( ImpMatch( aTmpWild.Copy( 0, nSepPos ).GetBuffer(), aString.GetBuffer() ) ) + return TRUE; + aTmpWild.Erase( 0, nSepPos + 1 ); // Trennsymbol entfernen + } + // und noch den hinter dem letzen Trennsymbol bzw. den einzigen + } + + if ( ImpMatch( aTmpWild.GetBuffer(), aString.GetBuffer() ) ) + return TRUE; + else + return FALSE; +} diff --git a/tools/source/fsys/wntmsc.cxx b/tools/source/fsys/wntmsc.cxx new file mode 100644 index 000000000000..b1ae509c6056 --- /dev/null +++ b/tools/source/fsys/wntmsc.cxx @@ -0,0 +1,1103 @@ +/************************************************************************* + * + * $RCSfile: wntmsc.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdio.h> +#include <ctype.h> +#include <limits.h> + +#include "wntmsc.hxx" +#include "errinf.hxx" + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _LIST_HXX +#include <list.hxx> +#endif +#ifndef _WLDCRD_HXX +#include <wldcrd.hxx> +#endif +#ifndef _FSYS_HXX +#include <fsys.hxx> +#endif +#ifndef _BIGINT_HXX +#include "bigint.hxx" +#endif + +DECLARE_LIST( DirEntryList, DirEntry* ); +DECLARE_LIST( FSysSortList, FSysSort* ); +DECLARE_LIST( FileStatList, FileStat* ); + +int Sys2SolarError_Impl( int nSysErr ); + +static ByteString sLastCaseSensitiveDir = ""; +static BOOL bLastCaseSensitive = FALSE; + +//-------------------------------------------------------------------- + +ByteString Upper_Impl( const ByteString &rStr ) +{ + ByteString aRet( rStr.GetBuffer() ); // es muss ein neuer String entstehen! + CharUpperBuff( (char*) aRet.GetBuffer(), aRet.Len() ); + return aRet; +} + +//-------------------------------------------------------------------- + +DIR *opendir( const char* pPfad ) +{ + DIR *pDir = new DIR; + if ( pDir ) + pDir->p = (char*) pPfad; + return pDir; +} + +struct dirent *readdir( DIR *pDir ) +{ + BOOL bOk = FALSE; + if ( pDir->p ) + { + char *pBuf = new char[ strlen( pDir->p ) + 5 ]; + if ( pBuf ) + { + // *.* dahinter, ggf mit "\\" abtrennen (falls nicht schon da) + strcpy( pBuf, pDir->p ); + strcat( pBuf, "\\*.*" + ( *(pBuf + strlen( pBuf ) - 1 ) == '\\' ) ); + CharUpperBuff( pBuf, strlen(pBuf) ); + pDir->h = FindFirstFile( pBuf, &pDir->aDirEnt ); + bOk = pDir->h != INVALID_HANDLE_VALUE; + pDir->p = NULL; + delete pBuf; + } + else + pDir->h = INVALID_HANDLE_VALUE; + } + else + { + bOk = FindNextFile( pDir->h, &pDir->aDirEnt ); + } + + return bOk ? &pDir->aDirEnt : NULL; +} + +int closedir( DIR *pDir ) +{ + BOOL bOk = FALSE; + if ( pDir ) + { + bOk = 0 != pDir->p || FindClose( pDir->h ); + delete pDir; + } + return bOk; +} + +/************************************************************************* +|* +|* DirEntry::GetPathStyle() const +|* +|* Beschreibung +|* Ersterstellung MI 11.05.95 +|* Letzte Aenderung MI 11.05.95 +|* +*************************************************************************/ + +ErrCode GetPathStyle_Impl( const String &rDevice, FSysPathStyle &rStyle ) +{ + ByteString aRootDir(rDevice, osl_getThreadTextEncoding()); + if ( aRootDir.Len() && aRootDir.GetBuffer()[aRootDir.Len()-1] != '\\' ) + aRootDir += '\\'; + + char sVolumeName[256]; + char sFileSysName[16]; + DWORD nSerial[2]; + DWORD nMaxCompLen[2]; + DWORD nFlags[2]; + + // Windows95 hat VFAT, WindowsNT nicht + DWORD nVer = GetVersion(); + BOOL bW95 = ( nVer & 0xFF ) >= 4; + + FSysFailOnErrorImpl(); + rStyle = FSYS_STYLE_UNKNOWN; + if ( GetVolumeInformation( + (char*) aRootDir.GetBuffer(), + sVolumeName, 256, (LPDWORD) &nSerial, (LPDWORD) &nMaxCompLen, + (LPDWORD) &nFlags, sFileSysName, 16 ) ) + { + // FAT/VFAT? + if ( 0 == strcmp( "FAT", sFileSysName ) ) + rStyle = bW95 ? FSYS_STYLE_VFAT : FSYS_STYLE_FAT; + + // NTFS? + else if ( 0 == strcmp( "NTFS", sFileSysName ) ) + rStyle = FSYS_STYLE_NTFS; + + // HPFS? + else if ( 0 == strcmp( "HPFS", sFileSysName ) ) + rStyle = FSYS_STYLE_HPFS; + + // NWCOMPA/NWFS? + else if ( 0 == strncmp( "NW", sFileSysName, 2 ) ) + rStyle = FSYS_STYLE_NWFS; + + return ERRCODE_NONE; + } + + return ERRCODE_IO_INVALIDDEVICE; +} + +FSysPathStyle DirEntry::GetPathStyle( const String &rDevice ) +{ + + FSysPathStyle eStyle; + GetPathStyle_Impl( rDevice, eStyle ); + return eStyle; +} + +/************************************************************************* +|* +|* DirEntry::IsCaseSensitive() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 10.06.93 +|* Letzte Aenderung TPF 26.02.1999 +|* +*************************************************************************/ + +BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const +{ + + if (eFormatter==FSYS_STYLE_HOST) + { +/* + DirEntry aRoot(*this); + aRoot.ToAbs(); + aRoot = aRoot[Level()-1]; + String aRootDir = aRoot.GetFull(FSYS_STYLE_HOST, TRUE); + + char sVolumeName[256]; + DWORD nVolumeSerial; + DWORD nMaxCompLen; + DWORD nFlags; + char sFileSysName[16]; + + if ( GetVolumeInformation( (char*) aRootDir.GetStr(), + sVolumeName, + 256, + (LPDWORD) &nVolumeSerial, + (LPDWORD) &nMaxCompLen, + (LPDWORD) &nFlags, + sFileSysName, + 16 )) + { + return (nFlags & FS_CASE_SENSITIVE) ? TRUE : FALSE; + } + else + { + return FALSE; + } +*/ + // + // guter versuch, aber FS_CASE_SENSITIVE ist D?nnsinn in T?ten: + // + // sFileSysName FS_CASE_SENSITIVE + // FAT FALSE + // NTFS TRUE !!! + // NWCompat FALSE + // Samba FALSE + // + // NT spricht auch NTFS lediglich case preserving an, also ist unter NT alles case insensitiv + // + + return FALSE; + } + else + { + BOOL isCaseSensitive = FALSE; // ich bin unter win32, also ist der default case insensitiv + switch ( eFormatter ) + { + case FSYS_STYLE_MAC: + case FSYS_STYLE_FAT: + case FSYS_STYLE_VFAT: + case FSYS_STYLE_NTFS: + case FSYS_STYLE_NWFS: + case FSYS_STYLE_HPFS: + case FSYS_STYLE_DETECT: + { + isCaseSensitive = FALSE; + break; + } + case FSYS_STYLE_SYSV: + case FSYS_STYLE_BSD: + { + isCaseSensitive = TRUE; + break; + } + default: + { + isCaseSensitive = FALSE; // ich bin unter win32, also ist der default case insensitiv + break; + } + } + return isCaseSensitive; + } +} + +/************************************************************************* +|* +|* DirEntry::ToAbs() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MA 02.12.91 +|* +*************************************************************************/ + +BOOL DirEntry::ToAbs() +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + if ( FSYS_FLAG_VOLUME == eFlag ) + { + eFlag = FSYS_FLAG_ABSROOT; + return TRUE; + } + + if ( IsAbs() ) + { + return TRUE; + } + + + char sBuf[256]; + char *pOld; + ByteString aFullName( GetFull(), osl_getThreadTextEncoding() ); + FSysFailOnErrorImpl(); + if ( GetFullPathName((char*)aFullName.GetBuffer(),256,sBuf,&pOld) > 511 ) + return FALSE; + + *this = DirEntry( String(sBuf, osl_getThreadTextEncoding() )); + return TRUE; +} + + +/************************************************************************* +|* +|* DirEntry::GetVolume() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 27.08.92 +|* Letzte Aenderung MI 28.08.92 +|* +*************************************************************************/ + +String DirEntry::GetVolume() const +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + String aRet; + const DirEntry *pTop = ImpGetTopPtr(); + ByteString aName = ByteString( pTop->aName ).ToLowerAscii(); + + if ( ( pTop->eFlag == FSYS_FLAG_ABSROOT || + pTop->eFlag == FSYS_FLAG_RELROOT || + pTop->eFlag == FSYS_FLAG_VOLUME ) + && aName != "a:" && aName != "b:" && Exists() ) + { + char sFileSysName[256]; + char sVolumeName[256]; + DWORD nVolumeNameLen = 256; + DWORD nSerial[2]; + DWORD nMaxCompLen[2]; + DWORD nFlags[2]; + ByteString aRootDir = pTop->aName; + FSysFailOnErrorImpl(); + + // Network-Device zuerst probieren wegen langsamer Samba-Drives + if ( !WNetGetConnection( (char*) aRootDir.GetBuffer(), + sVolumeName, &nVolumeNameLen ) ) + aRet = String( sVolumeName, osl_getThreadTextEncoding()); + + // dann den VolumeNamen fuer lokale Drives + if ( aRet.Len() == 0 ) + { + aRootDir += "\\"; + if ( GetVolumeInformation( (char*) aRootDir.GetBuffer(), + sVolumeName, 256, + (LPDWORD) &nSerial, (LPDWORD) &nMaxCompLen, + (LPDWORD) &nFlags, sFileSysName, 256 ) ) + aRet = String( sVolumeName, osl_getThreadTextEncoding()); + } + } + + return aRet; +} + +/************************************************************************* +|* +|* DirEntry::SetCWD() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 26.04.91 +|* Letzte Aenderung MI 21.05.92 +|* +*************************************************************************/ + +BOOL DirEntry::SetCWD( BOOL bSloppy ) +{ + DBG_CHKTHIS( DirEntry, ImpCheckDirEntry ); + + FSysFailOnErrorImpl(); + + if ( eFlag == FSYS_FLAG_CURRENT && !aName.Len() ) + return TRUE; + + if ( SetCurrentDirectory(ByteString(GetFull(), osl_getThreadTextEncoding()).GetBuffer()) ) + { + nError = FSYS_ERR_OK; + return TRUE; + } + + if ( bSloppy && pParent && + SetCurrentDirectory(ByteString(pParent->GetFull(), osl_getThreadTextEncoding()).GetBuffer()) ) + { + nError = FSYS_ERR_OK; + return TRUE; + } + + nError = FSYS_ERR_NOTADIRECTORY; + return FALSE; +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Init() +{ + // Block-Devices auflisten? + if ( pDir->eAttrMask & FSYS_KIND_BLOCK ) + { + // CWD merken + DirEntry aCurrentDir; + aCurrentDir.ToAbs(); + + // einzeln auf Existenz und Masken-konformit"at pr"ufen + USHORT nRead = 0; + char sDrive[3] = { '?', ':', 0 }; + char sRoot[4] = { '?', ':', '\\', 0 }; + for ( char c = 'a'; c <= 'z'; c++ ) + { + sDrive[0] = c; + sRoot[0] = c; + DirEntry* pDrive = new DirEntry( sDrive, FSYS_FLAG_VOLUME, FSYS_STYLE_HOST ); + if ( pDir->aNameMask.Matches( String( ByteString(sDrive), osl_getThreadTextEncoding())) && GetDriveType( sRoot ) != 1 ) + { + if ( pDir->pStatLst ) //Status fuer Sort gewuenscht? + { + FileStat *pNewStat = new FileStat( *pDrive ); + pDir->ImpSortedInsert( pDrive, pNewStat ); + } + else + pDir->ImpSortedInsert( pDrive, NULL ); + ++nRead; + } + else + delete pDrive; + } + + // CWD restaurieren + aCurrentDir.SetCWD(); + return nRead; + } + + return 0; +} + +//------------------------------------------------------------------------- + +USHORT DirReader_Impl::Read() +{ + // Directories und Files auflisten? + if ( ( pDir->eAttrMask & FSYS_KIND_DIR || + pDir->eAttrMask & FSYS_KIND_FILE ) && + ( ( pDosEntry = readdir( pDosDir ) ) != NULL ) ) + { + // Gross/Kleinschreibung nicht beruecksichtigen + ByteString aLowerName = pDosEntry->d_name; + CharLowerBuff( (char*) aLowerName.GetBuffer(), aLowerName.Len() ); + + // Flags pruefen + BOOL bIsDirAndWantsDir = + ( ( pDir->eAttrMask & FSYS_KIND_DIR ) && +#ifdef ICC + ( pDosEntry->d_type & ( strcmp(pDosEntry->d_name,".") || + strcmp(pDosEntry->d_name,"..")) ) ); +#else + ( pDosEntry->d_type & DOS_DIRECT ) ); +#endif + BOOL bIsFileAndWantsFile = + ( ( pDir->eAttrMask & FSYS_KIND_FILE ) && +#ifdef ICC + !( pDosEntry->d_type & ( strcmp(pDosEntry->d_name,".") || + strcmp(pDosEntry->d_name,"..")) ) && +#else + !( pDosEntry->d_type & DOS_DIRECT ) && +#endif + !( pDosEntry->d_type & DOS_VOLUMEID ) ); + BOOL bIsHidden = pDosEntry->d_type & _A_HIDDEN; + BOOL bWantsHidden = 0 == ( pDir->eAttrMask & FSYS_KIND_VISIBLE ); + if ( ( bIsDirAndWantsDir || bIsFileAndWantsFile ) && + ( bWantsHidden || !bIsHidden ) && + pDir->aNameMask.Matches( String(aLowerName, osl_getThreadTextEncoding()) ) ) + { +#ifdef DBG_UTIL + DbgOutf( "%s %s flags:%x found", + pDosEntry->d_name, + bIsFileAndWantsFile ? "file" : "dir", + pDosEntry->d_type ); +#endif + DirEntryFlag eFlag = + 0 == strcmp( pDosEntry->d_name, "." ) ? FSYS_FLAG_CURRENT + : 0 == strcmp( pDosEntry->d_name, ".." ) ? FSYS_FLAG_PARENT + : FSYS_FLAG_NORMAL; + DirEntry *pTemp = new DirEntry( ByteString(pDosEntry->d_name), + eFlag, FSYS_STYLE_NTFS ); +#ifdef FEAT_FSYS_DOUBLESPEED + pTemp->ImpSetStat( new FileStat( (void*) pDosDir, (void*) 0 ) ); +#endif + if ( pParent ) + pTemp->ImpChangeParent( new DirEntry( *pParent ), FALSE ); + if ( pDir->pStatLst ) //Status fuer Sort gewuenscht? + { + FileStat *pNewStat = new FileStat( (void*) pDosDir, (void*) 0 ); + pDir->ImpSortedInsert( pTemp, pNewStat ); + } + else + pDir->ImpSortedInsert( pTemp, NULL ); + return 1; + } +#ifdef DBG_UTIL + else + DbgOutf( "%s flags:%x skipped", + pDosEntry->d_name, + pDosEntry->d_type ); +#endif + + } + else + bReady = TRUE; + return 0; +} + +/************************************************************************* +|* +|* InitFileStat() +|* +|* Beschreibung gemeinsamer Teil der Ctoren fuer FileStat +|* Ersterstellung MI 28.08.92 +|* Letzte Aenderung MI 28.08.92 +|* +*************************************************************************/ + +void FileStat::ImpInit( void* p ) +{ + _WIN32_FIND_DATAA *pDirEnt = (_WIN32_FIND_DATAA*) p; + + nError = FSYS_ERR_OK; + nSize = pDirEnt->nFileSizeLow; + + SYSTEMTIME aSysTime; + FILETIME aLocTime; + + FileTimeToLocalFileTime( &pDirEnt->ftCreationTime, &aLocTime ); + FileTimeToSystemTime( &aLocTime, &aSysTime ); + aDateCreated = Date( aSysTime.wDay, aSysTime.wMonth, aSysTime.wYear ); + aTimeCreated = Time( aSysTime.wHour, aSysTime.wMinute, + aSysTime.wSecond, 0 ); + + FileTimeToLocalFileTime( &pDirEnt->ftLastWriteTime, &aLocTime ); + FileTimeToSystemTime( &aLocTime, &aSysTime ); + aDateModified = Date( aSysTime.wDay, aSysTime.wMonth, aSysTime.wYear ); + aTimeModified = Time( aSysTime.wHour, aSysTime.wMinute, + aSysTime.wSecond, 0 ); + + FileTimeToLocalFileTime( &pDirEnt->ftLastAccessTime, &aLocTime ); + FileTimeToSystemTime( &aLocTime, &aSysTime ); + aDateAccessed = Date( aSysTime.wDay, aSysTime.wMonth, aSysTime.wYear ); + aTimeAccessed = Time( aSysTime.wHour, aSysTime.wMinute, + aSysTime.wSecond, 0 ); + + nKindFlags = FSYS_KIND_FILE; + if ( pDirEnt->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + nKindFlags = FSYS_KIND_DIR; +} + +/************************************************************************* +|* +|* FileStat::FileStat() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 27.08.92 +|* Letzte Aenderung MI 28.08.92 +|* +*************************************************************************/ + +FileStat::FileStat( const void *pInfo, // struct dirent + const void * ): // dummy + aDateCreated(0), + aTimeCreated(0), + aDateModified(0), + aTimeModified(0), + aDateAccessed(0), + aTimeAccessed(0) +{ + ImpInit( ( (dirent*) pInfo ) ); +} + +/************************************************************************* +|* +|* FileStat::Update() +|* +|* Beschreibung FSYS.SDW +|* Ersterstellung MI 27.08.92 +|* Letzte Aenderung MI 28.08.92 +|* +*************************************************************************/ + +#ifdef ENABLEUNICODE +// #define UNICODE +#endif + +#include <prewin.h> +#include <shlobj.h> +#include <postwin.h> + +#ifdef UNICODE +#define lstrchr wcschr +#define lstrncmp wcsncmp +#else +#define lstrchr strchr +#define lstrncmp strncmp +#endif + +//--------------------------------------------------------------------------- + +void SHFreeMem( void *p ) +{ + LPMALLOC pMalloc = NULL; + + if ( SUCCEEDED(SHGetMalloc(&pMalloc)) ) + { + pMalloc->Free( p ); + pMalloc->Release(); + } +} + +//--------------------------------------------------------------------------- + +HRESULT SHGetIDListFromPath( HWND hwndOwner, LPCTSTR pszPath, LPITEMIDLIST *ppidl ) +{ + if ( IsBadWritePtr(ppidl, sizeof(LPITEMIDLIST)) ) + return E_INVALIDARG; + + LPSHELLFOLDER pDesktopFolder = NULL; + + HRESULT hResult = SHGetDesktopFolder( &pDesktopFolder ); + if ( FAILED(hResult) ) + return hResult; + + ULONG chEaten = lstrlen( pszPath ); + DWORD dwAttributes = FILE_ATTRIBUTE_DIRECTORY; + +#ifdef UNICODE + LPOLESTR wszPath = pszPath; +#else + WCHAR wszPath[MAX_PATH]; + MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, pszPath, -1, wszPath, MAX_PATH ); +#endif + + hResult = pDesktopFolder->ParseDisplayName( hwndOwner, (LPBC)NULL, wszPath, &chEaten, ppidl, &dwAttributes ); + pDesktopFolder->Release(); + + return hResult; +} + +//--------------------------------------------------------------------------- + +HRESULT SHGetFolderFromIDList( LPCITEMIDLIST pidl, LPSHELLFOLDER *ppFolder ) +{ + if ( IsBadWritePtr(ppFolder, sizeof(LPSHELLFOLDER)) ) + return E_INVALIDARG; + + *ppFolder = NULL; + + LPSHELLFOLDER pDesktopFolder = NULL; + + HRESULT hResult = SHGetDesktopFolder( &pDesktopFolder ); + if ( FAILED(hResult) ) + return hResult; + + hResult = pDesktopFolder->BindToObject( pidl, (LPBC)NULL, IID_IShellFolder, (LPVOID *)ppFolder ); + pDesktopFolder->Release(); + + return hResult; +} + +//--------------------------------------------------------------------------- + +HRESULT SHResolvePath( HWND hwndOwner, LPCTSTR pszPath, LPITEMIDLIST *ppidl ) +{ + // If hwndOwner is NULL, use the desktop window, because dialogs need a parent + +#ifdef BOOTSTRAP + return NO_ERROR; +#else + if ( !hwndOwner ) + hwndOwner = GetDesktopWindow(); + + HRESULT hResult = NOERROR; + LPTSTR pszPathCopy; + LPTSTR pszTrailingPath; + TCHAR cBackup; + + // First make a copy of the path + + pszPathCopy = new TCHAR[lstrlen(pszPath) + 1]; + if ( pszPathCopy ) + lstrcpy( pszPathCopy, pszPath ); + else + return E_OUTOFMEMORY; + + // Determine the first token + + if ( !lstrncmp( pszPathCopy, "\\\\", 2 ) ) + pszTrailingPath = lstrchr( pszPathCopy + 2, '\\' ); + else + pszTrailingPath = lstrchr( pszPathCopy, '\\' ); + + // Now scan the path tokens + + while ( SUCCEEDED(hResult) ) + { + if ( pszTrailingPath ) + { + cBackup = *(++pszTrailingPath); + *pszTrailingPath = 0; + } + + LPITEMIDLIST pidl = NULL; + + // Make item ID list from leading path + + hResult = SHGetIDListFromPath( hwndOwner, pszPathCopy, &pidl ); + + // if path exists try to open it as folder + + if ( SUCCEEDED(hResult) ) + { + // Only open the folder if it was not the last token + + if ( pszTrailingPath ) + { + LPSHELLFOLDER pFolder; + + // Create a folder instance + hResult = SHGetFolderFromIDList( pidl, &pFolder); + + // Is it a folder ? + if ( SUCCEEDED(hResult) ) + { + // No try to instantiate an enumerator. + // This should popup a login dialog if any + + LPENUMIDLIST pEnum = NULL; + + hResult = pFolder->EnumObjects( hwndOwner, + SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN, + &pEnum ); + + // Release the enumerator interface + if ( SUCCEEDED(hResult) ) + pEnum->Release(); + + // Release the folder interface + pFolder->Release(); + } + + SHFreeMem( pidl ); + } + else // It was the last token + { + if ( ppidl ) + *ppidl = pidl; + else + SHFreeMem( pidl ); + } + } + + + // Forward to next token + + if ( pszTrailingPath ) + { + *pszTrailingPath = cBackup; + pszTrailingPath = lstrchr( pszTrailingPath, '\\' ); + } + else + break; + } + + // Free the working copy of the path + delete pszPathCopy; + + // NOERROR or OLE error code + return hResult; +#endif +} + +//--------------------------------------------------------------------------- +// The Wrapper +//--------------------------------------------------------------------------- + +BOOL Exists_Impl( const ByteString & crPath ) +{ + // We do not know if OLE was initialized for this thread + + CoInitialize( NULL ); + + BOOL bSuccess = SUCCEEDED( SHResolvePath(NULL, crPath.GetBuffer(), NULL) ); + + CoUninitialize(); + + return bSuccess; +} + +//--------------------------------------------------------------------------- + +BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess ) +{ + nSize = 0; + nKindFlags = 0; + aCreator.Erase(); + aType.Erase(); + aDateCreated = Date(0); + aTimeCreated = Time(0); + aDateModified = Date(0); + aTimeModified = Time(0); + aDateAccessed = Date(0); + aTimeAccessed = Time(0); + + if ( !rDirEntry.IsValid() ) + { + nError = FSYS_ERR_UNKNOWN; + nKindFlags = 0; + return FALSE; + } + + // Sonderbehandlung falls es sich um eine Root ohne Laufwerk handelt + + if ( !rDirEntry.aName.Len() && rDirEntry.eFlag == FSYS_FLAG_ABSROOT ) + { + nKindFlags = FSYS_KIND_DIR; + nError = FSYS_ERR_OK; + return TRUE; + } + + // keine Error-Boxen anzeigen + FSysFailOnErrorImpl(); + + // Redirect + String aPath( rDirEntry.GetFull() ); +#ifndef BOOTSTRAP + BOOL bRedirected = FSysRedirector::DoRedirect( aPath ); +#endif + DirEntry aDirEntry( aPath ); + + // ist ein Medium im Laufwerk? + HACK("wie?") + BOOL bAccess = TRUE; + const DirEntry *pTop = aDirEntry.ImpGetTopPtr(); + ByteString aName = ByteString(pTop->aName).ToLowerAscii(); + if ( !bForceAccess && + ( pTop->eFlag == FSYS_FLAG_ABSROOT || + pTop->eFlag == FSYS_FLAG_RELROOT || + pTop->eFlag == FSYS_FLAG_VOLUME ) ) + if ( aName == "a:" || aName == "b:" ) + bAccess = FALSE; + else + DBG_TRACE( "FSys: will access removable device!" ); + if ( bAccess && ( aName == "a:" || aName == "b:" ) ) + DBG_WARNING( "floppy will clatter" ); + + // Sonderbehandlung, falls es sich um ein Volume handelt + if ( aDirEntry.eFlag == FSYS_FLAG_VOLUME || + aDirEntry.eFlag == FSYS_FLAG_ABSROOT ) + { + if ( aDirEntry.eFlag == FSYS_FLAG_VOLUME ) + nKindFlags = FSYS_KIND_DEV | ( aDirEntry.aName.Len() == 2 + ? FSYS_KIND_BLOCK + : FSYS_KIND_CHAR ); + else + nKindFlags = FSYS_KIND_DIR; + + if ( !bAccess ) + { + if ( aDirEntry.eFlag == FSYS_FLAG_VOLUME ) + nKindFlags |= FSYS_KIND_REMOVEABLE; + nError = FSYS_ERR_NOTEXISTS; + nKindFlags = 0; + return FALSE; + } + + ByteString aRootDir = aDirEntry.aName; + aRootDir += ByteString( "\\" ); + USHORT nType = GetDriveType( (char *) aRootDir.GetBuffer() ); //TPF: 2i + if ( nType == 1 || nType == 0 ) + { + nError = FSYS_ERR_NOTEXISTS; + nKindFlags = 0; + return FALSE; + } + + if ( aDirEntry.eFlag == FSYS_FLAG_VOLUME ) + nKindFlags = nKindFlags | + ( ( nType == DRIVE_REMOVABLE ) ? FSYS_KIND_REMOVEABLE : 0 ) | + ( ( nType == DRIVE_FIXED ) ? FSYS_KIND_FIXED : 0 ) | + ( ( nType == DRIVE_REMOTE ) ? FSYS_KIND_REMOTE : 0 ) | + ( ( nType == DRIVE_RAMDISK ) ? FSYS_KIND_RAM : 0 ) | + ( ( nType == DRIVE_CDROM ) ? FSYS_KIND_CDROM : 0 ) | + ( ( nType == 0 ) ? FSYS_KIND_UNKNOWN : 0 ); + + nError = ERRCODE_NONE; + + return TRUE; + } + + // Statusinformation vom Betriebssystem holen + HANDLE h; //() + _WIN32_FIND_DATAA aEntry; + DirEntry aAbsEntry( aDirEntry ); + if ( bAccess && aAbsEntry.ToAbs() ) + { + // im Namen k"onnen auch ';*?' als normale Zeichen vorkommen + ByteString aFilePath( aAbsEntry.GetFull(), osl_getThreadTextEncoding() ); + + // MI: dann gehen Umlaute auf Novell-Servern nicht / wozu ueberhaupt + // CharUpperBuff( (char*) aFilePath.GetStr(), aFilePath.Len() ); + DBG_TRACE1( "FileStat: %s", aFilePath.GetBuffer() ); + h = aFilePath.Len() < 230 + // die Win32-API ist hier sehr schwammig + ? FindFirstFile( (char *) aFilePath.GetBuffer(), &aEntry )//TPF: 2i + : INVALID_HANDLE_VALUE; + + if ( INVALID_HANDLE_VALUE != h ) + { + if ( !( aEntry.dwFileAttributes & 0x40 ) ) // com1: etc. e.g. not encrypted (means normal) + { + ByteString aUpperName = Upper_Impl(ByteString(aAbsEntry.GetName(), osl_getThreadTextEncoding())); + + // HRO: #74051# Compare also with short alternate filename + if ( aUpperName != Upper_Impl( aEntry.cFileName ) && aUpperName != Upper_Impl( aEntry.cAlternateFileName ) ) + h = INVALID_HANDLE_VALUE; + } + } + + if ( INVALID_HANDLE_VALUE == h ) + { + DWORD dwError = GetLastError(); + + if ( ERROR_BAD_NET_NAME == dwError ) + { + nKindFlags = FSYS_KIND_UNKNOWN; + nError = FSYS_ERR_NOTEXISTS; + return FALSE; + } + + // UNC-Volume? + DirEntry *pTop = aAbsEntry.ImpGetTopPtr(); + if ( pTop->GetFlag() == FSYS_FLAG_ABSROOT && + ( pTop->aName.Len() > 1 && (pTop->aName.GetBuffer()[1] != ':' )) ) + { + if ( bForceAccess ) + { + if ( Exists_Impl( aFilePath ) ) + { + nKindFlags = FSYS_KIND_DIR|FSYS_KIND_REMOTE; + nError = FSYS_ERR_OK; + return TRUE; + } + else + { + nKindFlags = FSYS_KIND_UNKNOWN; + nError = FSYS_ERR_NOTEXISTS; + return FALSE; + } + } + } + } + } + else + h = INVALID_HANDLE_VALUE; + + if ( h == INVALID_HANDLE_VALUE ) + { + // Sonderbehandlung falls es sich um eine Wildcard handelt + ByteString aTempName( aDirEntry.GetName(), osl_getThreadTextEncoding() ); + if ( strchr( aTempName.GetBuffer(), '?' ) || + strchr( aTempName.GetBuffer(), '*' ) || + strchr( aTempName.GetBuffer(), ';' ) ) + { + nKindFlags = FSYS_KIND_WILD; + nError = FSYS_ERR_OK; + return TRUE; + } + + if ( bAccess ) + { + nError = FSYS_ERR_NOTEXISTS; + nKindFlags = FSYS_KIND_UNKNOWN; + } + else + nKindFlags = FSYS_KIND_REMOVEABLE; + } + else + { + ImpInit( &aEntry ); + FindClose( h ); + } + + if ( 0 != nError ) + nKindFlags = 0; + + return 0 == nError; + +} + +BOOL IsRedirectable_Impl( const ByteString &rPath ) +{ + if ( rPath.Len() >= 3 && ':' == rPath.GetBuffer()[1] ) + { + ByteString aVolume = rPath.Copy( 0, 3 ); + USHORT nType = GetDriveType( (char *) aVolume.GetBuffer() ); + SetLastError( ERROR_SUCCESS ); + return DRIVE_FIXED != nType; + } + return FALSE; +} + +/************************************************************************* +|* +|* TempDirImpl() +|* +|* Beschreibung liefert den Namens des Directories fuer temporaere +|* Dateien +|* Ersterstellung MI 16.03.94 +|* Letzte Aenderung MI 16.03.94 +|* +*************************************************************************/ + +const char* TempDirImpl( char *pBuf ) +{ + if ( !GetTempPath( MAX_PATH, pBuf ) && + !GetWindowsDirectory( pBuf, MAX_PATH ) && + !GetEnvironmentVariable( "HOMEPATH", pBuf, MAX_PATH ) ) + return 0; + + return pBuf; +} + +//======================================================================= + +ErrCode FileStat::QueryDiskSpace( const String &rPath, + BigInt &rFreeBytes, BigInt &rTotalBytes ) +{ + DWORD nSectorsPerCluster; /* address of sectors per cluster */ + DWORD nBytesPerSector; /* address of bytes per sector */ + DWORD nFreeClusters; /* address of number of free clusters */ + DWORD nClusters; /* address of total number of clusters */ + + ByteString aVol( DirEntry(rPath).ImpGetTopPtr()->GetName(), osl_getThreadTextEncoding()); + BOOL bOK = GetDiskFreeSpace( aVol.GetBuffer(), + &nSectorsPerCluster, &nBytesPerSector, + &nFreeClusters, &nClusters ); + if ( !bOK ) + return Sys2SolarError_Impl( GetLastError() ); + + BigInt aBytesPerCluster( BigInt(nSectorsPerCluster) * + BigInt(nBytesPerSector) ); + rFreeBytes = aBytesPerCluster * BigInt(nFreeClusters); + rTotalBytes = aBytesPerCluster * BigInt(nClusters); + return 0; +} + +//========================================================================= + +void FSysEnableSysErrorBox( BOOL bEnable ) +{ // Preserve other Bits!! + sal_uInt32 nErrorMode = SetErrorMode( bEnable ? 0 : SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX ); + if ( bEnable ) + nErrorMode &= ~(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX); + else + nErrorMode |= (SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX); + SetErrorMode( nErrorMode ); +} + + + diff --git a/tools/source/fsys/wntmsc.hxx b/tools/source/fsys/wntmsc.hxx new file mode 100644 index 000000000000..e51931fc4173 --- /dev/null +++ b/tools/source/fsys/wntmsc.hxx @@ -0,0 +1,130 @@ +/************************************************************************* + * + * $RCSfile: wntmsc.hxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _dosmsc_hxx +#define _dosmsc_hxx + +#include <string.h> + +#ifndef ICC +#include <io.h> +#endif +#include <sys\types.h> +#include <sys\stat.h> +#include <direct.h> + +#include <svwin.h> +#include <winbase.h> +#include <solar.h> +#include <string.hxx> + +//-------------------------------------------------------------------- + +#define FSYS_UNIX FALSE + +#define DOS_DIRECT _A_SUBDIR +#define DOS_VOLUMEID 0x08 +#ifndef S_IFBLK +#define S_IFBLK 0x6000 +#endif +#define setdrive(n,a) _chdrive(n) +#define GETDRIVE(n) (n = _getdrive()) + +#define dirent _WIN32_FIND_DATAA +#define d_name cFileName +#define d_type dwFileAttributes + +#if defined (TCPP) || defined (tcpp) +#define _mkdir mkdir +#define _rmdir rmdir +#define _chdir chdir +#define _unlink unlink +#define _getcwd getcwd +#define _access access +#endif + +typedef struct +{ + _WIN32_FIND_DATAA aDirEnt; + HANDLE h; + const char *p; +} DIR; + +#define PATHDELIMITER ";" +#define DEFSTYLE FSYS_STYLE_NTFS +#define MKDIR( p ) mkdir( p ) +#define CMP_LOWER(s) ( ByteString(s).ToLowerAscii() ) + +#include <svwin.h> +#define START_DRV 'a' + +inline BOOL DRIVE_EXISTS(char c) +{ + ByteString aDriveRoot( c ); + aDriveRoot += ":\\"; + return GetDriveType( aDriveRoot.GetBuffer() ) > 1; +} + +const char* TempDirImpl( char *pBuf ); + +#define FSysFailOnErrorImpl() + +#endif diff --git a/tools/source/generic/bigint.cxx b/tools/source/generic/bigint.cxx new file mode 100644 index 000000000000..352731311a6c --- /dev/null +++ b/tools/source/generic/bigint.cxx @@ -0,0 +1,1187 @@ +/************************************************************************* + * + * $RCSfile: bigint.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <math.h> +#include <tools.h> + +#define private public +#include <bigint.hxx> +#undef private + +#ifndef _STRING_HXX +#include <string.hxx> +#endif +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif + +#include <string.h> +#include <ctype.h> + +static void SubLong( BigInt& rA, BigInt& rB, BigInt& rErg ); + +static const long MY_MAXLONG = 0x3fffffff; +static const long MY_MINLONG = -MY_MAXLONG; +static const long MY_MAXSHORT = 0x00007fff; +static const long MY_MINSHORT = -MY_MAXSHORT; + +/* Die ganzen Algorithmen zur Addition, Subtraktion, Multiplikation und + * Division von langen Zahlen stammen aus SEMINUMERICAL ALGORITHMS von + * DONALD E. KNUTH aus der Reihe The Art of Computer Programming. Zu finden + * sind diese Algorithmen im Kapitel 4.3.1. The Classical Algorithms. + */ + +// Muss auf UINT16/INT16/UINT32/INT32 umgestellt werden !!! W.P. + +// ----------------------------------------------------------------------- + +static void MakeBigInt( BigInt& rThis, const BigInt& rVal ) +{ + if ( rVal.bIsBig ) + { + memcpy( (void*)&rThis, (const void*)&rVal, sizeof( BigInt ) ); + while ( rThis.nLen > 1 && rThis.nNum[rThis.nLen-1] == 0 ) + rThis.nLen--; + } + else + { + long nTmp = rVal.nVal; + + rThis.nVal = rVal.nVal; + rThis.bIsBig = TRUE; + if ( nTmp < 0 ) + { + rThis.bIsNeg = TRUE; + nTmp = -nTmp; + } + else + rThis.bIsNeg = FALSE; + + rThis.nNum[0] = (USHORT)(nTmp & 0xffffL); + rThis.nNum[1] = (USHORT)(nTmp >> 16); +#ifndef _WIN16 + if ( nTmp & 0xffff0000L ) +#else + long l = 0xffff0000L; + if ( nTmp & l ) +#endif + rThis.nLen = 2; + else + rThis.nLen = 1; + } +} + +// ----------------------------------------------------------------------- + +static void Normalize( BigInt& rThis ) +{ + if ( rThis.bIsBig ) + { + while ( rThis.nLen > 1 && rThis.nNum[rThis.nLen-1] == 0 ) + rThis.nLen--; + + if ( rThis.nLen < 3 ) + { + if ( rThis.nLen < 2 ) + rThis.nVal = rThis.nNum[0]; + else if ( rThis.nNum[1] & 0x8000 ) + return; + else + rThis.nVal = ((long)rThis.nNum[1] << 16) + rThis.nNum[0]; + + rThis.bIsBig = FALSE; + + if ( rThis.bIsNeg ) + rThis.nVal = -rThis.nVal; + } + // else ist nVal undefiniert !!! W.P. + } + // wozu, nLen ist doch undefiniert ??? W.P. + else if ( rThis.nVal & 0xFFFF0000L ) + rThis.nLen = 2; + else + rThis.nLen = 1; +} + +// ----------------------------------------------------------------------- + +static void Mult( BigInt& rThis, const BigInt &rVal, USHORT nMul ) +{ + USHORT nK = 0; + for ( int i = 0; i < rVal.nLen; i++ ) + { + ULONG nTmp = (ULONG)rVal.nNum[i] * (ULONG)nMul + nK; + nK = (USHORT)(nTmp >> 16); + rThis.nNum[i] = (USHORT)nTmp; + } + + if ( nK ) + { + rThis.nNum[rVal.nLen] = nK; + rThis.nLen = rVal.nLen + 1; + } + else + rThis.nLen = rVal.nLen; + + rThis.bIsBig = TRUE; + rThis.bIsNeg = rVal.bIsNeg; +} + +// ----------------------------------------------------------------------- + +static void Div( BigInt& rThis, USHORT nDiv, USHORT& rRem ) +{ + ULONG nK = 0; + for ( int i = rThis.nLen - 1; i >= 0; i-- ) + { + ULONG nTmp = (ULONG)rThis.nNum[i] + (nK << 16); + rThis.nNum[i] = (USHORT)(nTmp / nDiv); + nK = nTmp % nDiv; + } + rRem = (USHORT)nK; + + if ( rThis.nNum[rThis.nLen-1] == 0 ) + rThis.nLen -= 1; +} + +// ----------------------------------------------------------------------- + +static BOOL IsLess( const BigInt& rThis, const BigInt& rVal ) +{ + if ( rVal.nLen < rThis.nLen) + return TRUE; + if ( rVal.nLen > rThis.nLen ) + return FALSE; + + int i; + for ( i = rThis.nLen - 1; i > 0 && rThis.nNum[i] == rVal.nNum[i]; i-- ) + { + } + return rVal.nNum[i] < rThis.nNum[i]; +} + +// ----------------------------------------------------------------------- + +static void AddLong( BigInt& rA, BigInt& rB, BigInt& rErg ) +{ + if ( rA.bIsNeg == rB.bIsNeg ) + { + int i; + char nLen; + + // wenn die Zahlen unterschiedlich lang sind, sollte zunaechst bei + // der kleineren Zahl die fehlenden Ziffern mit 0 initialisert werden + if (rA.nLen >= rB.nLen) + { + nLen = rA.nLen; + for (i = rB.nLen; i < nLen; i++) + rB.nNum[i] = 0; + } + else + { + nLen = rB.nLen; + for (i = rA.nLen; i < nLen; i++) + rA.nNum[i] = 0; + } + + // Die Ziffern werden von hinten nach vorne addiert + long k; + long nZ = 0; + for (i = 0, k = 0; i < nLen; i++) { + nZ = (long)rA.nNum[i] + (long)rB.nNum[i] + k; + if (nZ & 0xff0000L) + k = 1; + else + k = 0; + rErg.nNum[i] = (USHORT)(nZ & 0xffffL); + } + // Trat nach der letzten Addition ein Ueberlauf auf, muss dieser + // noch ins Ergebis uebernommen werden + if (nZ & 0xff0000L) // oder if(k) + { + rErg.nNum[i] = 1; + nLen++; + } + // Die Laenge und das Vorzeichen setzen + rErg.nLen = nLen; + rErg.bIsNeg = rA.bIsNeg && rB.bIsNeg; + rErg.bIsBig = TRUE; + } + // Wenn nur einer der beiden Operanten negativ ist, wird aus der + // Addition eine Subtaktion + else if (rA.bIsNeg) + { + rA.bIsNeg = FALSE; + SubLong(rB, rA, rErg); + rA.bIsNeg = TRUE; + } + else + { + rB.bIsNeg = FALSE; + SubLong(rA, rB, rErg); + rB.bIsNeg = TRUE; + } +} + +// ----------------------------------------------------------------------- + +static void SubLong( BigInt& rA, BigInt& rB, BigInt& rErg ) +{ + if ( rA.bIsNeg == rB.bIsNeg ) + { + int i; + char nLen; + long nZ, k; + + // wenn die Zahlen unterschiedlich lang sind, sollte zunaechst bei + // der kleineren Zahl die fehlenden Ziffern mit 0 initialisert werden + if (rA.nLen >= rB.nLen) + { + nLen = rA.nLen; + for (i = rB.nLen; i < nLen; i++) + rB.nNum[i] = 0; + } + else + { + nLen = rB.nLen; + for (i = rA.nLen; i < nLen; i++) + rA.nNum[i] = 0; + } + + if ( IsLess(rA, rB) ) + { + for (i = 0, k = 0; i < nLen; i++) + { + nZ = (long)rA.nNum[i] - (long)rB.nNum[i] + k; + if (nZ < 0) + k = -1; + else + k = 0; + rErg.nNum[i] = (USHORT)(nZ & 0xffffL); + } + rErg.bIsNeg = rA.bIsNeg; + } + else + { + for (i = 0, k = 0; i < nLen; i++) + { + nZ = (long)rB.nNum[i] - (long)rA.nNum[i] + k; + if (nZ < 0) + k = -1; + else + k = 0; + rErg.nNum[i] = (USHORT)(nZ & 0xffffL); + } + // wenn a < b, dann Vorzeichen vom Ergebnis umdrehen + rErg.bIsNeg = !rA.bIsNeg; + } + rErg.nLen = nLen; + rErg.bIsBig = TRUE; + } + // Wenn nur einer der beiden Operanten negativ ist, wird aus der + // Subtaktion eine Addition + else if (rA.bIsNeg) + { + rA.bIsNeg = FALSE; + AddLong(rA, rB, rErg); + rA.bIsNeg = TRUE; + rErg.bIsNeg = TRUE; + } + else + { + rB.bIsNeg = FALSE; + AddLong(rA, rB, rErg); + rB.bIsNeg = TRUE; + rErg.bIsNeg = FALSE; + } +} + +// ----------------------------------------------------------------------- + +static void MultLong( const BigInt& rA, const BigInt& rB, BigInt& rErg ) +{ + int i, j; + ULONG nZ, k; + + rErg.bIsNeg = rA.bIsNeg != rB.bIsNeg; + rErg.bIsBig = TRUE; + rErg.nLen = rA.nLen + rB.nLen; + + for (i = 0; i < rErg.nLen; i++) + rErg.nNum[i] = 0; + + for (j = 0; j < rB.nLen; j++) + { + for (i = 0, k = 0; i < rA.nLen; i++) + { + nZ = (ULONG)rA.nNum[i] * (ULONG)rB.nNum[j] + + (ULONG)rErg.nNum[i + j] + k; + rErg.nNum[i + j] = (USHORT)(nZ & 0xffffUL); + k = nZ >> 16; + } + rErg.nNum[i + j] = (USHORT)k; + } +} + +// ----------------------------------------------------------------------- + +static void DivLong( const BigInt& rA, const BigInt& rB, BigInt& rErg ) +{ + int i, j; + long nTmp; + USHORT nK, nQ, nMult; + short nLenB = rB.nLen; + short nLenB1 = rB.nLen - 1; + BigInt aTmpA, aTmpB; + + nMult = (USHORT)(0x10000L / ((long)rB.nNum[nLenB1] + 1)); + + Mult( aTmpA, rA, nMult ); + if ( aTmpA.nLen == rA.nLen ) + { + aTmpA.nNum[aTmpA.nLen] = 0; + aTmpA.nLen++; + } + + Mult( aTmpB, rB, nMult ); + + for (j = aTmpA.nLen - 1; j >= nLenB; j--) + { // Raten des Divisors + nTmp = ( (long)aTmpA.nNum[j] << 16 ) + aTmpA.nNum[j - 1]; + if (aTmpA.nNum[j] == aTmpB.nNum[nLenB1]) + nQ = 0xFFFF; + else + nQ = (USHORT)(((ULONG)nTmp) / aTmpB.nNum[nLenB1]); + + if ( ((ULONG)aTmpB.nNum[nLenB1 - 1] * nQ) > + ((((ULONG)nTmp) - aTmpB.nNum[nLenB1] * nQ) << 16) + aTmpA.nNum[j - 2]) + nQ--; + // Und hier faengt das Teilen an + nK = 0; + nTmp = 0; + for (i = 0; i < nLenB; i++) + { + nTmp = (long)aTmpA.nNum[j - nLenB + i] + - ((long)aTmpB.nNum[i] * nQ) + - nK; + aTmpA.nNum[j - nLenB + i] = (USHORT)nTmp; + nK = (USHORT) (nTmp >> 16); + if ( nK ) + nK = (USHORT)(0x10000UL - nK); + } + aTmpA.nNum[j - nLenB + i] -= nK; + if (aTmpA.nNum[j - nLenB + i] == 0) + rErg.nNum[j - nLenB] = nQ; + else + { + rErg.nNum[j - nLenB] = nQ - 1; + nK = 0; + for (i = 0; i < nLenB; i++) + { + nTmp = aTmpA.nNum[j - nLenB + i] + aTmpB.nNum[i] + nK; + aTmpA.nNum[j - nLenB + i] = (USHORT)(nTmp & 0xFFFFL); + if (nTmp & 0xFFFF0000L) + nK = 1; + else + nK = 0; + } + } + } + + rErg.bIsNeg = rA.bIsNeg != rB.bIsNeg; + rErg.bIsBig = TRUE; + rErg.nLen = rA.nLen - rB.nLen + 1; +} + +// ----------------------------------------------------------------------- + +static void ModLong( const BigInt& rA, const BigInt& rB, BigInt& rErg ) +{ + short i, j; + long nTmp; + USHORT nK, nQ, nMult; + short nLenB = rB.nLen; + short nLenB1 = rB.nLen - 1; + BigInt aTmpA, aTmpB; + + nMult = (USHORT)(0x10000L / ((long)rB.nNum[nLenB1] + 1)); + + Mult( aTmpA, rA, nMult); + if ( aTmpA.nLen == rA.nLen ) + { + aTmpA.nNum[aTmpA.nLen] = 0; + aTmpA.nLen++; + } + + Mult( aTmpB, rB, nMult); + + for (j = aTmpA.nLen - 1; j >= nLenB; j--) + { // Raten des Divisors + nTmp = ( (long)aTmpA.nNum[j] << 16 ) + aTmpA.nNum[j - 1]; + if (aTmpA.nNum[j] == aTmpB.nNum[nLenB1]) + nQ = 0xFFFF; + else + nQ = (USHORT)(((ULONG)nTmp) / aTmpB.nNum[nLenB1]); + + if ( ((ULONG)aTmpB.nNum[nLenB1 - 1] * nQ) > + ((((ULONG)nTmp) - aTmpB.nNum[nLenB1] * nQ) << 16) + aTmpA.nNum[j - 2]) + nQ--; + // Und hier faengt das Teilen an + nK = 0; + nTmp = 0; + for (i = 0; i < nLenB; i++) + { + nTmp = (long)aTmpA.nNum[j - nLenB + i] + - ((long)aTmpB.nNum[i] * nQ) + - nK; + aTmpA.nNum[j - nLenB + i] = (USHORT)nTmp; + nK = (USHORT) (nTmp >> 16); + if ( nK ) + nK = (USHORT)(0x10000UL - nK); + } + aTmpA.nNum[j - nLenB + i] -= nK; + if (aTmpA.nNum[j - nLenB + i] == 0) + rErg.nNum[j - nLenB] = nQ; + else + { + rErg.nNum[j - nLenB] = nQ - 1; + nK = 0; + for (i = 0; i < nLenB; i++) { + nTmp = aTmpA.nNum[j - nLenB + i] + aTmpB.nNum[i] + nK; + aTmpA.nNum[j - nLenB + i] = (USHORT)(nTmp & 0xFFFFL); + if (nTmp & 0xFFFF0000L) + nK = 1; + else + nK = 0; + } + } + } + + rErg = aTmpA; + Div( rErg, nMult, nQ ); +} + +// ----------------------------------------------------------------------- + +static BOOL ABS_IsLess( const BigInt& rA, const BigInt& rB ) +{ + if (rA.bIsBig || rB.bIsBig) + { + BigInt nA, nB; + MakeBigInt( nA, rA ); + MakeBigInt( nB, rB ); + if (nA.nLen == nB.nLen) + { + int i; + for (i = nA.nLen - 1; i > 0 && nA.nNum[i] == nB.nNum[i]; i--) + { + } + return nA.nNum[i] < nB.nNum[i]; + } + else + return nA.nLen < nB.nLen; + } + if ( rA.nVal < 0 ) + if ( rB.nVal < 0 ) + return rA.nVal > rB.nVal; + else + return rA.nVal > -rB.nVal; + else + if ( rB.nVal < 0 ) + return rA.nVal < -rB.nVal; + else + return rA.nVal < rB.nVal; +} + +// ----------------------------------------------------------------------- + +BigInt::BigInt( const BigInt& rBigInt ) +{ + if ( rBigInt.bIsBig ) + memcpy( (void*)this, (const void*)&rBigInt, sizeof( BigInt ) ); + else + { + bIsSet = rBigInt.bIsSet; + bIsBig = FALSE; + nVal = rBigInt.nVal; + } +} + +// ----------------------------------------------------------------------- + +BigInt::BigInt( const ByteString& rString ) +{ + bIsSet = TRUE; + bIsNeg = FALSE; + bIsBig = FALSE; + nVal = 0; + + BOOL bNeg = FALSE; + const sal_Char* p = rString.GetBuffer(); + if ( *p == '-' ) + { + bNeg = TRUE; + p++; + } + while( *p >= '0' && *p <= '9' ) + { + *this *= 10; + *this += *p - '0'; + p++; + } + if ( bIsBig ) + bIsNeg = bNeg; + else if( bNeg ) + nVal = -nVal; +} + +// ----------------------------------------------------------------------- + +BigInt::BigInt( const UniString& rString ) +{ + bIsSet = TRUE; + bIsNeg = FALSE; + bIsBig = FALSE; + nVal = 0; + + BOOL bNeg = FALSE; + const sal_Unicode* p = rString.GetBuffer(); + if ( *p == '-' ) + { + bNeg = TRUE; + p++; + } + while( *p >= '0' && *p <= '9' ) + { + *this *= 10; + *this += *p - '0'; + p++; + } + if ( bIsBig ) + bIsNeg = bNeg; + else if( bNeg ) + nVal = -nVal; +} + +// ----------------------------------------------------------------------- + +BigInt::BigInt( double nValue ) +{ + bIsSet = TRUE; + + if ( nValue < 0 ) + { + nValue *= -1; + bIsNeg = TRUE; + } + else + { + bIsNeg = FALSE; + } + + if ( nValue < 1 ) + { + bIsBig = FALSE; + nVal = 0; + } + else + { + bIsBig = TRUE; + + int i=0; + + while ( ( nValue > 65536.0 ) && ( i < MAX_DIGITS ) ) + { + nNum[i] = (USHORT) fmod( nValue, 65536.0 ); + nValue -= nNum[i]; + nValue /= 65536.0; + i++; + } + if ( i < MAX_DIGITS ) + nNum[i++] = (USHORT) nValue; + + nLen = i; + + if ( i < 3 ) + Normalize( *this ); + } +} + +// ----------------------------------------------------------------------- + +BigInt::BigInt( ULONG nValue ) +{ +#if __SIZEOFLONG != 4 + #error sizeof (long) != 4: API auf INTxx umstellen +#else + bIsSet = TRUE; + if ( nValue & 0x80000000UL ) + { + bIsBig = TRUE; + bIsNeg = FALSE; + nNum[0] = (USHORT)(nValue & 0xffffUL); + nNum[1] = (USHORT)(nValue >> 16); + nLen = 2; + } + else + { + bIsBig = FALSE; + nVal = nValue; + } +#endif +} + +// ----------------------------------------------------------------------- + +BigInt::operator ULONG() const +{ + if ( !bIsBig ) + return (ULONG)nVal; + else if ( nLen == 2 ) + { + ULONG nRet; + nRet = ((ULONG)nNum[1]) << 16; + nRet += nNum[0]; + return nRet; + } + return 0; +} + +// ----------------------------------------------------------------------- + +BigInt::operator double() const +{ + if ( !bIsBig ) + return (double) nVal; + else + { + int i = nLen-1; + double nRet = (double) ((ULONG)nNum[i]); + + while ( i ) + { + nRet *= 65536.0; + i--; + nRet += (double) ((ULONG)nNum[i]); + } + + if ( bIsNeg ) + nRet *= -1; + + return nRet; + } +} + +// ----------------------------------------------------------------------- + +ByteString BigInt::GetByteString() const +{ + ByteString aString; + + if ( !bIsBig ) + aString = nVal; + else + { + BigInt aTmp( *this ); + BigInt a1000000000( 1000000000L ); + aTmp.Abs(); + + do + { + BigInt a = aTmp; + a %= a1000000000; + aTmp /= a1000000000; + + ByteString aStr = aString; + if ( a.nVal < 100000000L ) + { // leading 0s + aString = ByteString::CreateFromInt32( a.nVal + 1000000000L ); + aString.Erase( 0, 1 ); + } + else + aString = ByteString::CreateFromInt32( a.nVal ); + aString += aStr; + } + while( aTmp.bIsBig ); + + ByteString aStr = aString; + if ( bIsNeg ) + aString = ByteString::CreateFromInt32( -aTmp.nVal ); + else + aString = ByteString::CreateFromInt32( aTmp.nVal ); + aString += aStr; + } + + return aString; +} + +// ----------------------------------------------------------------------- + +#ifdef ENABLEUNICODE + +UniString BigInt::GetString() const +{ + UniString aString; + + if ( !bIsBig ) + aString = nVal; + else + { + BigInt aTmp( *this ); + BigInt a1000000000( 1000000000L ); + aTmp.Abs(); + + do + { + BigInt a = aTmp; + a %= a1000000000; + aTmp /= a1000000000; + + UniString aStr = aString; + if ( a.nVal < 100000000L ) + { // leading 0s + aString = UniString::CreateFromInt32( a.nVal + 1000000000L ); + aString.Erase(0,1); + } + else + aString = UniString::CreateFromInt32( a.nVal ); + aString += aStr; + } + while( aTmp.bIsBig ); + + UniString aStr = aString; + if ( bIsNeg ) + aString = UniString::CreateFromInt32( -aTmp.nVal ); + else + aString = UniString::CreateFromInt32( aTmp.nVal ); + aString += aStr; + } + + return aString; +} + +#endif + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator=( const BigInt& rBigInt ) +{ + if ( rBigInt.bIsBig ) + memcpy( (void*)this, (const void*)&rBigInt, sizeof( BigInt ) ); + else + { + bIsSet = rBigInt.bIsSet; + bIsBig = FALSE; + nVal = rBigInt.nVal; + } + return *this; +} + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator+=( const BigInt& rVal ) +{ + if ( !bIsBig && !rVal.bIsBig ) + { + if( nVal <= MY_MAXLONG && rVal.nVal <= MY_MAXLONG + && nVal >= MY_MINLONG && rVal.nVal >= MY_MINLONG ) + { // wir bewegen uns im ungefaehrlichem Bereich + nVal += rVal.nVal; + return *this; + } + + if( (nVal < 0) != (rVal.nVal < 0) ) + { // wir bewegen uns im ungefaehrlichem Bereich + nVal += rVal.nVal; + return *this; + } + } + + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, *this ); + MakeBigInt( aTmp2, rVal ); + AddLong( aTmp1, aTmp2, *this ); + Normalize( *this ); + return *this; +} + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator-=( const BigInt& rVal ) +{ + if ( !bIsBig && !rVal.bIsBig ) + { + if ( nVal <= MY_MAXLONG && rVal.nVal <= MY_MAXLONG && + nVal >= MY_MINLONG && rVal.nVal >= MY_MINLONG ) + { // wir bewegen uns im ungefaehrlichem Bereich + nVal -= rVal.nVal; + return *this; + } + + if ( (nVal < 0) == (rVal.nVal < 0) ) + { // wir bewegen uns im ungefaehrlichem Bereich + nVal -= rVal.nVal; + return *this; + } + } + + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, *this ); + MakeBigInt( aTmp2, rVal ); + SubLong( aTmp1, aTmp2, *this ); + Normalize( *this ); + return *this; +} + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator*=( const BigInt& rVal ) +{ + if ( !bIsBig && !rVal.bIsBig + && nVal <= MY_MAXSHORT && rVal.nVal <= MY_MAXSHORT + && nVal >= MY_MINSHORT && rVal.nVal >= MY_MINSHORT ) + // nicht optimal !!! W.P. + { // wir bewegen uns im ungefaehrlichem Bereich + nVal *= rVal.nVal; + } + else + { + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, rVal ); + MakeBigInt( aTmp2, *this ); + MultLong(aTmp1, aTmp2, *this); + Normalize( *this ); + } + return *this; +} + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator/=( const BigInt& rVal ) +{ + if ( !rVal.bIsBig ) + { + if ( rVal.nVal == 0 ) + { + DBG_ERROR( "BigInt::operator/ --> divide by zero" ); + return *this; + } + + if ( !bIsBig ) + { + // wir bewegen uns im ungefaehrlichem Bereich + nVal /= rVal.nVal; + return *this; + } + + if ( rVal.nVal == 1 ) + return *this; + + if ( rVal.nVal == -1 ) + { + bIsNeg = !bIsNeg; + return *this; + } + + if ( rVal.nVal <= (long)0xFFFF && rVal.nVal >= -(long)0xFFFF ) + { + // ein BigInt durch ein USHORT teilen + USHORT nTmp; + if ( rVal.nVal < 0 ) + { + nTmp = (USHORT) -rVal.nVal; + bIsNeg = !bIsNeg; + } + else + nTmp = (USHORT) rVal.nVal; + + Div( *this, nTmp, nTmp ); + Normalize( *this ); + return *this; + } + } + + if ( ABS_IsLess( *this, rVal ) ) + { + *this = BigInt( (long)0 ); + return *this; + } + + // BigInt durch BigInt teilen + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, *this ); + MakeBigInt( aTmp2, rVal ); + DivLong(aTmp1, aTmp2, *this); + Normalize( *this ); + return *this; +} + +// ----------------------------------------------------------------------- + +void BigInt::DivMod( const BigInt& rVal, BigInt& rMod ) +{ + if ( !rVal.bIsBig ) + { + if ( rVal.nVal == 0 ) + { + DBG_ERROR( "BigInt::operator/ --> divide by zero" ); + return; + } + + if ( !bIsBig ) + { + // wir bewegen uns im ungefaehrlichem Bereich + rMod = BigInt( nVal % rVal.nVal ); + nVal /= rVal.nVal; + return; + } + + if ( rVal.nVal == 1 ) + { + rMod = BigInt( (long)0 ); + return; + } + + if ( rVal.nVal == -1 ) + { + rMod = BigInt( (long)0 ); + bIsNeg = !bIsNeg; + return; + } + + if ( rVal.nVal <= (long)0xFFFF && rVal.nVal >= -(long)0xFFFF ) + { + // ein BigInt durch ein USHORT teilen + USHORT nTmp; + if ( rVal.nVal < 0 ) + { + nTmp = (USHORT) -rVal.nVal; + bIsNeg = !bIsNeg; + } + else + nTmp = (USHORT) rVal.nVal; + + Div( *this, nTmp, nTmp ); + rMod = BigInt( (long)nTmp ); + Normalize( *this ); + return; + } + } + + if ( ABS_IsLess( *this, rVal ) ) + { + rMod = *this; + *this = BigInt( (long)0 ); + return; + } + + // BigInt durch BigInt teilen + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, *this ); + MakeBigInt( aTmp2, rVal ); + DivLong(aTmp1, aTmp2, *this); + Normalize( *this ); + ModLong(aTmp1, aTmp2, rMod); // nicht optimal + Normalize( rMod ); +} + +// ----------------------------------------------------------------------- + +BigInt& BigInt::operator%=( const BigInt& rVal ) +{ + if ( !rVal.bIsBig ) + { + if ( rVal.nVal == 0 ) + { + DBG_ERROR( "BigInt::operator/ --> divide by zero" ); + return *this; + } + + if ( !bIsBig ) + { + // wir bewegen uns im ungefaehrlichem Bereich + nVal %= rVal.nVal; + return *this; + } + + if ( rVal.nVal <= (long)0xFFFF && rVal.nVal >= -(long)0xFFFF ) + { + // ein BigInt durch ein short teilen + USHORT nTmp; + if ( rVal.nVal < 0 ) + { + nTmp = (USHORT) -rVal.nVal; + bIsNeg = !bIsNeg; + } + else + nTmp = (USHORT) rVal.nVal; + + Div( *this, nTmp, nTmp ); + *this = BigInt( (long)nTmp ); + return *this; + } + } + + if ( ABS_IsLess( *this, rVal ) ) + return *this; + + // BigInt durch BigInt teilen + BigInt aTmp1, aTmp2; + MakeBigInt( aTmp1, *this ); + MakeBigInt( aTmp2, rVal ); + ModLong(aTmp1, aTmp2, *this); + Normalize( *this ); + return *this; +} + +// ----------------------------------------------------------------------- + +BOOL operator==( const BigInt& rVal1, const BigInt& rVal2 ) +{ + if ( rVal1.bIsBig || rVal2.bIsBig ) + { + BigInt nA, nB; + MakeBigInt( nA, rVal1 ); + MakeBigInt( nB, rVal2 ); + if ( nA.bIsNeg == nB.bIsNeg ) + { + if ( nA.nLen == nB.nLen ) + { + int i; + for ( i = nA.nLen - 1; i > 0 && nA.nNum[i] == nB.nNum[i]; i-- ) + { + } + + return nA.nNum[i] == nB.nNum[i]; + } + return FALSE; + } + return FALSE; + } + return rVal1.nVal == rVal2.nVal; +} + +// ----------------------------------------------------------------------- + +BOOL operator<( const BigInt& rVal1, const BigInt& rVal2 ) +{ + if ( rVal1.bIsBig || rVal2.bIsBig ) + { + BigInt nA, nB; + MakeBigInt( nA, rVal1 ); + MakeBigInt( nB, rVal2 ); + if ( nA.bIsNeg == nB.bIsNeg ) + { + if ( nA.nLen == nB.nLen ) + { + int i; + for ( i = nA.nLen - 1; i > 0 && nA.nNum[i] == nB.nNum[i]; i-- ) + { + } + + if ( nA.bIsNeg ) + return nA.nNum[i] > nB.nNum[i]; + else + return nA.nNum[i] < nB.nNum[i]; + } + if ( nA.bIsNeg ) + return nA.nLen > nB.nLen; + else + return nA.nLen < nB.nLen; + } + return !nB.bIsNeg; + } + return rVal1.nVal < rVal2.nVal; +} + +// ----------------------------------------------------------------------- + +BOOL operator >(const BigInt& rVal1, const BigInt& rVal2 ) +{ + if ( rVal1.bIsBig || rVal2.bIsBig ) + { + BigInt nA, nB; + MakeBigInt( nA, rVal1 ); + MakeBigInt( nB, rVal2 ); + if ( nA.bIsNeg == nB.bIsNeg ) + { + if ( nA.nLen == nB.nLen ) + { + int i; + for ( i = nA.nLen - 1; i > 0 && nA.nNum[i] == nB.nNum[i]; i-- ) + { + } + + if ( nA.bIsNeg ) + return nA.nNum[i] < nB.nNum[i]; + else + return nA.nNum[i] > nB.nNum[i]; + } + if ( nA.bIsNeg ) + return nA.nLen < nB.nLen; + else + return nA.nLen > nB.nLen; + } + return !nA.bIsNeg; + } + + return rVal1.nVal > rVal2.nVal; +} diff --git a/tools/source/generic/color.cxx b/tools/source/generic/color.cxx new file mode 100644 index 000000000000..f3ca447bffb5 --- /dev/null +++ b/tools/source/generic/color.cxx @@ -0,0 +1,403 @@ +/************************************************************************* + * + * $RCSfile: color.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdlib.h> + +#ifndef _VOS_MACROS_HXX_ +#include <vos/macros.hxx> +#endif + +#ifndef _TOOLS_COLOR_HXX +#include <color.hxx> +#endif +#ifndef _TOOLS_DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _STREAM_HXX +#include <stream.hxx> +#endif + +// ----------- +// - Inlines - +// ----------- + +static inline long _FRound( double fVal ) +{ + return( fVal > 0.0 ? (long) ( fVal + 0.5 ) : -(long) ( -fVal + 0.5 ) ); +} + +// --------- +// - Color - +// --------- + +UINT8 Color::GetColorError( const Color& rCompareColor ) const +{ + const long nErrAbs = labs( (long) rCompareColor.GetRed() - GetRed() ) + + labs( (long) rCompareColor.GetGreen() - GetGreen() ) + + labs( (long) rCompareColor.GetBlue() - GetBlue() ); + + return (UINT8) _FRound( nErrAbs * 0.3333333333 ); +} + +// ----------------------------------------------------------------------- + +void Color::IncreaseLuminance( UINT8 cLumInc ) +{ + SetRed( (UINT8) VOS_BOUND( (long) COLORDATA_RED( mnColor ) + cLumInc, 0L, 255L ) ); + SetGreen( (UINT8) VOS_BOUND( (long) COLORDATA_GREEN( mnColor ) + cLumInc, 0L, 255L ) ); + SetBlue( (UINT8) VOS_BOUND( (long) COLORDATA_BLUE( mnColor ) + cLumInc, 0L, 255L ) ); +} + +// ----------------------------------------------------------------------- + +void Color::DecreaseLuminance( UINT8 cLumDec ) +{ + SetRed( (UINT8) VOS_BOUND( (long) COLORDATA_RED( mnColor ) - cLumDec, 0L, 255L ) ); + SetGreen( (UINT8) VOS_BOUND( (long) COLORDATA_GREEN( mnColor ) - cLumDec, 0L, 255L ) ); + SetBlue( (UINT8) VOS_BOUND( (long) COLORDATA_BLUE( mnColor ) - cLumDec, 0L, 255L ) ); +} + +// ----------------------------------------------------------------------- + +void Color::IncreaseContrast( UINT8 cContInc ) +{ + if( cContInc) + { + const double fM = 128.0 / ( 128.0 - 0.4985 * cContInc ); + const double fOff = 128.0 - fM * 128.0; + + SetRed( (UINT8) VOS_BOUND( _FRound( COLORDATA_RED( mnColor ) * fM + fOff ), 0L, 255L ) ); + SetGreen( (UINT8) VOS_BOUND( _FRound( COLORDATA_GREEN( mnColor ) * fM + fOff ), 0L, 255L ) ); + SetBlue( (UINT8) VOS_BOUND( _FRound( COLORDATA_BLUE( mnColor ) * fM + fOff ), 0L, 255L ) ); + } +} + +// ----------------------------------------------------------------------- + +void Color::DecreaseContrast( UINT8 cContDec ) +{ + if( cContDec ) + { + const double fM = ( 128.0 - 0.4985 * cContDec ) / 128.0; + const double fOff = 128.0 - fM * 128.0; + + SetRed( (UINT8) VOS_BOUND( _FRound( COLORDATA_RED( mnColor ) * fM + fOff ), 0L, 255L ) ); + SetGreen( (UINT8) VOS_BOUND( _FRound( COLORDATA_GREEN( mnColor ) * fM + fOff ), 0L, 255L ) ); + SetBlue( (UINT8) VOS_BOUND( _FRound( COLORDATA_BLUE( mnColor ) * fM + fOff ), 0L, 255L ) ); + } +} + +// ----------------------------------------------------------------------- + +void Color::Invert() +{ + SetRed( ~COLORDATA_RED( mnColor ) ); + SetGreen( ~COLORDATA_GREEN( mnColor ) ); + SetBlue( ~COLORDATA_BLUE( mnColor ) ); +} + +// ----------------------------------------------------------------------- + +SvStream& Color::Read( SvStream& rIStm, BOOL bNewFormat ) +{ + if ( bNewFormat ) + rIStm >> mnColor; + else + rIStm >> *this; + + return rIStm; +} + +// ----------------------------------------------------------------------- + +SvStream& Color::Write( SvStream& rOStm, BOOL bNewFormat ) +{ + if ( bNewFormat ) + rOStm << mnColor; + else + rOStm << *this; + + return rOStm; +} + +// ----------------------------------------------------------------------- + +#define COL_NAME_USER ((USHORT)0x8000) +#define COL_RED_1B ((USHORT)0x0001) +#define COL_RED_2B ((USHORT)0x0002) +#define COL_GREEN_1B ((USHORT)0x0010) +#define COL_GREEN_2B ((USHORT)0x0020) +#define COL_BLUE_1B ((USHORT)0x0100) +#define COL_BLUE_2B ((USHORT)0x0200) + +// ----------------------------------------------------------------------- + +SvStream& operator>>( SvStream& rIStream, Color& rColor ) +{ + DBG_ASSERTWARNING( rIStream.GetVersion(), "Color::>> - Solar-Version not set on rIStream" ); + + USHORT nColorName; + USHORT nRed; + USHORT nGreen; + USHORT nBlue; + + rIStream >> nColorName; + + if ( nColorName & COL_NAME_USER ) + { + if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cAry[6]; + USHORT i = 0; + + nRed = 0; + nGreen = 0; + nBlue = 0; + + if ( nColorName & COL_RED_2B ) + i += 2; + else if ( nColorName & COL_RED_1B ) + i++; + if ( nColorName & COL_GREEN_2B ) + i += 2; + else if ( nColorName & COL_GREEN_1B ) + i++; + if ( nColorName & COL_BLUE_2B ) + i += 2; + else if ( nColorName & COL_BLUE_1B ) + i++; + + rIStream.Read( cAry, i ); + i = 0; + + if ( nColorName & COL_RED_2B ) + { + nRed = cAry[i]; + nRed <<= 8; + i++; + nRed |= cAry[i]; + i++; + } + else if ( nColorName & COL_RED_1B ) + { + nRed = cAry[i]; + nRed <<= 8; + i++; + } + if ( nColorName & COL_GREEN_2B ) + { + nGreen = cAry[i]; + nGreen <<= 8; + i++; + nGreen |= cAry[i]; + i++; + } + else if ( nColorName & COL_GREEN_1B ) + { + nGreen = cAry[i]; + nGreen <<= 8; + i++; + } + if ( nColorName & COL_BLUE_2B ) + { + nBlue = cAry[i]; + nBlue <<= 8; + i++; + nBlue |= cAry[i]; + i++; + } + else if ( nColorName & COL_BLUE_1B ) + { + nBlue = cAry[i]; + nBlue <<= 8; + i++; + } + } + else + { + rIStream >> nRed; + rIStream >> nGreen; + rIStream >> nBlue; + } + + rColor.mnColor = RGB_COLORDATA( nRed>>8, nGreen>>8, nBlue>>8 ); + } + else + { + static ColorData aColAry[] = + { + COL_BLACK, // COL_BLACK + COL_BLUE, // COL_BLUE + COL_GREEN, // COL_GREEN + COL_CYAN, // COL_CYAN + COL_RED, // COL_RED + COL_MAGENTA, // COL_MAGENTA + COL_BROWN, // COL_BROWN + COL_GRAY, // COL_GRAY + COL_LIGHTGRAY, // COL_LIGHTGRAY + COL_LIGHTBLUE, // COL_LIGHTBLUE + COL_LIGHTGREEN, // COL_LIGHTGREEN + COL_LIGHTCYAN, // COL_LIGHTCYAN + COL_LIGHTRED, // COL_LIGHTRED + COL_LIGHTMAGENTA, // COL_LIGHTMAGENTA + COL_YELLOW, // COL_YELLOW + COL_WHITE, // COL_WHITE + COL_WHITE, // COL_MENUBAR + COL_BLACK, // COL_MENUBARTEXT + COL_WHITE, // COL_POPUPMENU + COL_BLACK, // COL_POPUPMENUTEXT + COL_BLACK, // COL_WINDOWTEXT + COL_WHITE, // COL_WINDOWWORKSPACE + COL_BLACK, // COL_HIGHLIGHT + COL_WHITE, // COL_HIGHLIGHTTEXT + COL_BLACK, // COL_3DTEXT + COL_LIGHTGRAY, // COL_3DFACE + COL_WHITE, // COL_3DLIGHT + COL_GRAY, // COL_3DSHADOW + COL_LIGHTGRAY, // COL_SCROLLBAR + COL_WHITE, // COL_FIELD + COL_BLACK // COL_FIELDTEXT + }; + + if ( nColorName < (sizeof( aColAry )/sizeof(ColorData)) ) + rColor.mnColor = aColAry[nColorName]; + else + rColor.mnColor = COL_BLACK; + } + + return rIStream; +} + +// ----------------------------------------------------------------------- + +SvStream& operator<<( SvStream& rOStream, const Color& rColor ) +{ + DBG_ASSERTWARNING( rOStream.GetVersion(), "Color::<< - Solar-Version not set on rOStream" ); + + USHORT nColorName = COL_NAME_USER; + USHORT nRed = rColor.GetRed(); + USHORT nGreen = rColor.GetGreen(); + USHORT nBlue = rColor.GetBlue(); + nRed = (nRed<<8) + nRed; + nGreen = (nGreen<<8) + nGreen; + nBlue = (nBlue<<8) + nBlue; + + if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cAry[6]; + USHORT i = 0; + + if ( nRed & 0x00FF ) + { + nColorName |= COL_RED_2B; + cAry[i] = (unsigned char)(nRed & 0xFF); + i++; + cAry[i] = (unsigned char)((nRed >> 8) & 0xFF); + i++; + } + else if ( nRed & 0xFF00 ) + { + nColorName |= COL_RED_1B; + cAry[i] = (unsigned char)((nRed >> 8) & 0xFF); + i++; + } + if ( nGreen & 0x00FF ) + { + nColorName |= COL_GREEN_2B; + cAry[i] = (unsigned char)(nGreen & 0xFF); + i++; + cAry[i] = (unsigned char)((nGreen >> 8) & 0xFF); + i++; + } + else if ( nGreen & 0xFF00 ) + { + nColorName |= COL_GREEN_1B; + cAry[i] = (unsigned char)((nGreen >> 8) & 0xFF); + i++; + } + if ( nBlue & 0x00FF ) + { + nColorName |= COL_BLUE_2B; + cAry[i] = (unsigned char)(nBlue & 0xFF); + i++; + cAry[i] = (unsigned char)((nBlue >> 8) & 0xFF); + i++; + } + else if ( nBlue & 0xFF00 ) + { + nColorName |= COL_BLUE_1B; + cAry[i] = (unsigned char)((nBlue >> 8) & 0xFF); + i++; + } + + rOStream << nColorName; + rOStream.Write( cAry, i ); + } + else + { + rOStream << nColorName; + rOStream << nRed; + rOStream << nGreen; + rOStream << nBlue; + } + + return rOStream; +} diff --git a/tools/source/generic/fract.cxx b/tools/source/generic/fract.cxx new file mode 100644 index 000000000000..6fc728df517f --- /dev/null +++ b/tools/source/generic/fract.cxx @@ -0,0 +1,720 @@ +/************************************************************************* + * + * $RCSfile: fract.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _LIMITS_H +#include <limits.h> +#endif + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif + +#ifndef _FRACT_HXX +#include <fract.hxx> +#endif + +#define private public +#define bIsLong bIsBig +#include <bigint.hxx> +#include <stream.hxx> + +/************************************************************************* +|* +|* GetGGT() +|* +|* Beschreibung Berechnet den groessten gemeinsamen Teiler von +|* nVal1 und nVal2 +|* Parameter long nVal1, long nVal2 +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Die Funktion GetGGT berechnet den groessten gemeinsamen Teiler der +// beiden als Parameter uebergebenen Werte nVal1 und nVal2 nach dem +// Algorithmus von Euklid. Hat einer der beiden Parameter den Wert 0 oder +// 1, so wird als Ergebnis der Wert 1 zurŸckgegeben. Da der Algorithmus +// nur mit positiven Zahlen arbeitet, werden die beiden Parameter +// entsprechend umgewandelt. +// Zum Algorithmus: die beiden Parameter werden solange ducheinander +// geteilt, bis sie beide gleich sind oder bis bei der Division +// kein Rest bleibt. Der kleinere der beiden Werte ist dann der +// GGT. + +static long GetGGT( long nVal1, long nVal2 ) +{ + nVal1 = Abs( nVal1 ); + nVal2 = Abs( nVal2 ); + + if ( nVal1 <= 1 || nVal2 <= 1 ) + return 1; + + while ( nVal1 != nVal2 ) + { + if ( nVal1 > nVal2 ) + { + nVal1 %= nVal2; + if ( nVal1 == 0 ) + return nVal2; + } + else + { + nVal2 %= nVal1; + if ( nVal2 == 0 ) + return nVal1; + } + } + + return nVal1; +} + +static void Reduce( BigInt &rVal1, BigInt &rVal2 ) +{ + BigInt nA( rVal1 ); + BigInt nB( rVal2 ); + nA.Abs(); + nB.Abs(); + + if ( nA.IsOne() || nB.IsOne() || nA.IsZero() || nB.IsZero() ) + return; + + while ( nA != nB ) + { + if ( nA > nB ) + { + nA %= nB; + if ( nA.IsZero() ) + { + rVal1 /= nB; + rVal2 /= nB; + return; + } + } + else + { + nB %= nA; + if ( nB.IsZero() ) + { + rVal1 /= nA; + rVal2 /= nA; + return; + } + } + } + + rVal1 /= nA; + rVal2 /= nB; +} + +/************************************************************************* +|* +|* Fraction::Fraction() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung WP 07.03.97 +|* Letzte Aenderung +|* +*************************************************************************/ + +Fraction::Fraction( long nN1, long nN2, long nD1, long nD2 ) +{ + long n; + int i = 1; + + if( nN1 < 0 ) { i = -i; nN1 = -nN1; } + if( nN2 < 0 ) { i = -i; nN2 = -nN2; } + if( nD1 < 0 ) { i = -i; nD1 = -nD1; } + if( nD2 < 0 ) { i = -i; nD2 = -nD2; } + + n = GetGGT( nN1, nD1 ); if( n > 1 ) { nN1 /= n; nD1 /= n; } + n = GetGGT( nN1, nD2 ); if( n > 1 ) { nN1 /= n; nD2 /= n; } + n = GetGGT( nN2, nD1 ); if( n > 1 ) { nN2 /= n; nD1 /= n; } + n = GetGGT( nN2, nD2 ); if( n > 1 ) { nN2 /= n; nD2 /= n; } + + BigInt nN( nN1 ); + nN *= BigInt( nN2 ); + + BigInt nD( nD1 ); + nD *= BigInt( nD2 ); + + while ( nN.bIsLong || nD.bIsLong ) + { + BigInt n1 = 1; + BigInt n2 = 2; + + nN += n1; + nN /= n2; + nD += n1; + nD /= n2; + + // Kuerzen ueber Groesste Gemeinsame Teiler + Reduce( nN, nD ); + } + + nNumerator = i * (long)nN; + nDenominator = (long)nD; +} + +/************************************************************************* +|* +|* Fraction::Fraction() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Zur Initialisierung eines Bruches wird nNum dem Zaehler und nDen dem +// Nenner zugewiesen. Da negative Werte des Nenners einen Bruch als +// ungueltig kennzeichnen, wird bei der Eingabe eines negativen Nenners +// sowohl das Vorzeichen des Nenners und des Zaehlers invertiert um wieder +// einen gueltigen Wert fuer den Bruch zu erhalten. + +Fraction::Fraction( long nNum, long nDen ) +{ + nNumerator = nNum; + nDenominator = nDen; + if ( nDenominator < 0 ) + { + nDenominator = -nDenominator; + nNumerator = -nNumerator; + } + + // Kuerzen ueber Groesste Gemeinsame Teiler + long n = GetGGT( nNumerator, nDenominator ); + nNumerator /= n; + nDenominator /= n; +} + +/************************************************************************* +|* +|* Fraction::Fraction() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Wenn der Wert von dVal groesser ist als LONG_MAX, dann wird der Bruch +// auf den Wert ungueltig gesetzt, ansonsten werden dVal und der Nenner +// solange mit 10 multipliziert, bis entweder der Zaehler oder der Nenner +// groesser als LONG_MAX / 10 ist. Zum Schluss wird der so entstandene Bruch +// gekuerzt. + +Fraction::Fraction( double dVal ) +{ + long nDen = 1; + long nMAX = LONG_MAX / 10; + + if ( dVal > LONG_MAX || dVal < LONG_MIN ) + { + nNumerator = 0; + nDenominator = -1; + return; + } + + while ( Abs( (long)dVal ) < nMAX && nDen < nMAX ) + { + dVal *= 10; + nDen *= 10; + } + nNumerator = (long)dVal; + nDenominator = nDen; + + // Kuerzen ueber Groesste Gemeinsame Teiler + long n = GetGGT( nNumerator, nDenominator ); + nNumerator /= n; + nDenominator /= n; +} + +/************************************************************************* +|* +|* Fraction::operator double() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 14.05.91 +|* +*************************************************************************/ + +Fraction::operator double() const +{ + if ( nDenominator > 0 ) + return (double)nNumerator / (double)nDenominator; + else + return (double)0; +} + +/************************************************************************* +|* +|* Fraction::operator+=() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft. +// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis +// ungueltig. Zur Addition werden die beiden Brueche erst durch +// Erweiterung mit den Nenner des jeweils anderen Bruches auf einen +// gemeinsamen Nenner gebracht. Anschliessend werden die beiden Zaehler +// addiert und das Ergebnis gekuerzt (durch Division von Zaehler und +// Nenner mit nGGT). Innerhalb der Funktion wird mit dem Datentyp SLong +// gerechnet, um einen Moeglichen Ueberlauf erkennen zu koennen. Bei +// einem Ueberlauf wird das Ergebnis auf den Wert ungueltig gesetzt. + +Fraction& Fraction::operator += ( const Fraction& rVal ) +{ + if ( !rVal.IsValid() ) + { + nNumerator = 0; + nDenominator = -1; + } + if ( !IsValid() ) + return *this; + + // (a/b) + (c/d) = ( (a*d) + (c*b) ) / (b*d) + BigInt nN( nNumerator ); + nN *= BigInt( rVal.nDenominator ); + BigInt nW1Temp( nDenominator ); + nW1Temp *= BigInt( rVal.nNumerator ); + nN += nW1Temp; + + BigInt nD( nDenominator ); + nD *= BigInt( rVal.nDenominator ); + + Reduce( nN, nD ); + + if ( nN.bIsLong || nD.bIsLong ) + { + nNumerator = 0; + nDenominator = -1; + } + else + { + nNumerator = (long)nN, + nDenominator = (long)nD; + } + + return *this; +} + +/************************************************************************* +|* +|* Fraction::operator-=() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft. +// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis +// ungueltig. Zur Subtraktion werden die beiden Brueche erst durch +// Erweiterung mit den Nenner des jeweils anderen Bruches auf einen +// gemeinsamen Nenner gebracht. Anschliessend werden die beiden Zaehler +// subtrahiert und das Ergebnis gekuerzt (durch Division von Zaehler und +// Nenner mit nGGT). Innerhalb der Funktion wird mit dem Datentyp BigInt +// gerechnet, um einen Moeglichen Ueberlauf erkennen zu koennen. Bei +// einem Ueberlauf wird das Ergebnis auf den Wert ungueltig gesetzt. + +Fraction& Fraction::operator -= ( const Fraction& rVal ) +{ + if ( !rVal.IsValid() ) + { + nNumerator = 0; + nDenominator = -1; + } + if ( !IsValid() ) + return *this; + + // (a/b) - (c/d) = ( (a*d) - (c*b) ) / (b*d) + BigInt nN( nNumerator ); + nN *= BigInt( rVal.nDenominator ); + BigInt nW1Temp( nDenominator ); + nW1Temp *= BigInt( rVal.nNumerator ); + nN -= nW1Temp; + + BigInt nD( nDenominator ); + nD *= BigInt( rVal.nDenominator ); + + Reduce( nN, nD ); + + if ( nN.bIsLong || nD.bIsLong ) + { + nNumerator = 0; + nDenominator = -1; + } + else + { + nNumerator = (long)nN, + nDenominator = (long)nD; + } + + return *this; +} + +/************************************************************************* +|* +|* Fraction::operator*=() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung TH 19.08.92 +|* +*************************************************************************/ + +// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft. +// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis +// ungueltig. Zur Multiplikation werden jeweils die beiden Zaehler und +// Nenner miteinander multipliziert. Um Ueberlaufe zu vermeiden, werden +// vorher jeweils der GGT zwischen dem Zaehler des einen und dem Nenner +// des anderen Bruches bestimmt und bei der Multiplikation Zaehler und +// Nenner durch die entsprechenden Werte geteilt. +// Innerhalb der Funktion wird mit dem Datentyp BigInt gerechnet, um +// einen Moeglichen Ueberlauf erkennen zu koennen. Bei einem Ueberlauf +// wird das Ergebnis auf den Wert ungueltig gesetzt. + +Fraction& Fraction::operator *= ( const Fraction& rVal ) +{ + if ( !rVal.IsValid() ) + { + nNumerator = 0; + nDenominator = -1; + } + if ( !IsValid() ) + return *this; + + long nGGT1 = GetGGT( nNumerator, rVal.nDenominator ); + long nGGT2 = GetGGT( rVal.nNumerator, nDenominator ); + BigInt nN( nNumerator / nGGT1 ); + nN *= BigInt( rVal.nNumerator / nGGT2 ); + BigInt nD( nDenominator / nGGT2 ); + nD *= BigInt( rVal.nDenominator / nGGT1 ); + + if ( nN.bIsLong || nD.bIsLong ) + { + nNumerator = 0; + nDenominator = -1; + } + else + { + nNumerator = (long)nN, + nDenominator = (long)nD; + } + + return *this; +} + +/************************************************************************* +|* +|* Fraction::operator/=() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft. +// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis +// ungueltig. +// Um den Bruch a durch b zu teilen, wird a mit dem Kehrwert von b +// multipliziert. Analog zu Multiplikation wird jezt jeweils der Zaehler +// des einen Bruches mit dem Nenner des anderen multipliziert. +// Um Ueberlaufe zu vermeiden, werden vorher jeweils der GGT zwischen den +// beiden Zaehlern und den beiden Nennern bestimmt und bei der +// Multiplikation Zaehler und Nenner durch die entsprechenden Werte +// geteilt. +// Innerhalb der Funktion wird mit dem Datentyp BigInt gerechnet, um +// einen Moeglichen Ueberlauf erkennen zu koennen. Bei einem Ueberlauf +// wird das Ergebnis auf den Wert ungueltig gesetzt. + +Fraction& Fraction::operator /= ( const Fraction& rVal ) +{ + if ( !rVal.IsValid() ) + { + nNumerator = 0; + nDenominator = -1; + } + if ( !IsValid() ) + return *this; + + long nGGT1 = GetGGT( nNumerator, rVal.nNumerator ); + long nGGT2 = GetGGT( rVal.nDenominator, nDenominator ); + BigInt nN( nNumerator / nGGT1 ); + nN *= BigInt( rVal.nDenominator / nGGT2 ); + BigInt nD( nDenominator / nGGT2 ); + nD *= BigInt( rVal.nNumerator / nGGT1 ); + + if ( nN.bIsLong || nD.bIsLong ) + { + nNumerator = 0; + nDenominator = -1; + } + else + { + nNumerator = (long)nN, + nDenominator = (long)nD; + if ( nDenominator < 0 ) + { + nDenominator = -nDenominator; + nNumerator = -nNumerator; + } + } + + return *this; +} + +/************************************************************************* +|* +|* Fraction::ReduceInaccurate() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung JOE 17.09.95 +|* Letzte Aenderung JOE 17.09.95 +|* +*************************************************************************/ + +// Funktioniert z.Zt. nur fuer 32-Bit Werte !!! +// Fehlerbehaftetes Kuerzen einer Fraction. +// nSignificantBits gibt an, wieviele signifikante Binaerstellen +// in Zaehler/Nenner mindestens erhalten bleiben sollen. +// Beispiel: ReduceInaccurate(8) hat einen Fehler <1% [1/2^(8-1)] +// dabei tritt der groesste Fehler bei folgendem Wertepaar auf: +// Binaer 1000000011111111111111111111111b/1000000000000000000000000000000b +// = 1082130431/1073741824 +// = ca. 1.007812499 +// Nach ReduceInaccurate( 8 ) wird daraus 1/1. + +void Fraction::ReduceInaccurate( unsigned nSignificantBits ) +{ + if ( !nNumerator || !nDenominator ) + return; + + // Zaehler und Nenner auf den Stack fuer schnelleren Zugriff + UINT32 nMul; + UINT32 nDiv; + BOOL bNeg; + if ( nNumerator >= 0 ) + { + nMul = (UINT32)nNumerator; + bNeg = FALSE; + } + else + { + nMul = (UINT32)(-nNumerator); + bNeg = TRUE; + } + nDiv=(UINT32)nDenominator; + + UINT32 a=nMul; unsigned nMulZ=0; // Fuehrende Nullen zaehlen + while (a<0x00800000) { nMulZ+=8; a<<=8; } + while (a<0x80000000) { nMulZ++; a<<=1; } + a=nDiv; unsigned nDivZ=0; // Fuehrende Nullen zaehlen + while (a<0x00800000) { nDivZ+=8; a<<=8; } + while (a<0x80000000) { nDivZ++; a<<=1; } + // Anzahl der verwendeten Digits bestimmen + // Auch hier gehe ich davon aus, dass es sich um 32Bit-Werte handelt + int nMulDigits=32-nMulZ; + int nDivDigits=32-nDivZ; + // Nun bestimmen, wieviele Stellen hinten weg koennen + // Hier koennte man das Ergebnis noch etwas optimieren... + int nMulWeg=nMulDigits-nSignificantBits; if (nMulWeg<0) nMulWeg=0; + int nDivWeg=nDivDigits-nSignificantBits; if (nDivWeg<0) nDivWeg=0; + int nWeg=Min(nMulWeg,nDivWeg); + nMul>>=nWeg; + nDiv>>=nWeg; + if ( !nMul || !nDiv ) + { + DBG_ERROR( "Oups, beim kuerzen einer Fraction hat sich Joe verrechnet." ); + return; + } + + // Nun noch kuerzen ueber GGT + long n1=GetGGT( nMul, nDiv ); + if ( n1!=1 ) + { + nMul/=n1; + nDiv/=n1; + } + if ( !bNeg ) + nNumerator = (long)nMul; + else + nNumerator = -(long)nMul; + nDenominator = nDiv; +} + +/************************************************************************* +|* +|* Fraction::operator ==() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung TH 19.08.92 +|* +*************************************************************************/ + +BOOL operator == ( const Fraction& rVal1, const Fraction& rVal2 ) +{ + if ( !rVal1.IsValid() || !rVal2.IsValid() ) + return FALSE; + + return rVal1.nNumerator == rVal2.nNumerator + && rVal1.nDenominator == rVal2.nDenominator; +} + +/************************************************************************* +|* +|* Fraction::operator <() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung DV 21.12.92 +|* +*************************************************************************/ + +// Beide Operanden werden zunaechst auf ihre Gueltigkeit ueberprueft und +// anschliessend zur Sicherheit noch einmal gekuerzt. Um die Brueche +// (a/b) und (c/d) zu vergleichen, werden sie zunaechst auf einen +// gemeinsamen Nenner gebracht (b*d), um dann die beiden Zaehler (a*d) +// und (c*b) zu vergleichen. Das Ergebnis dieses Vergleichs wird +// zurueckgegeben. + +BOOL operator < ( const Fraction& rVal1, const Fraction& rVal2 ) +{ + if ( !rVal1.IsValid() || !rVal2.IsValid() ) + return FALSE; + + BigInt nN( rVal1.nNumerator ); + nN *= BigInt( rVal2.nDenominator ); + BigInt nD( rVal1.nDenominator ); + nD *= BigInt( rVal2.nNumerator ); + + return nN < nD; +} + +/************************************************************************* +|* +|* Fraction::operator >() +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung DV 20.09.90 +|* Letzte Aenderung TH 19.08.92 +|* +*************************************************************************/ + +// Beide Operanden werden zunaechst auf ihre Gueltigkeit ueberprueft und +// anschliessend zur Sicherheit noch einmal gekuerzt. Um die Brueche +// (a/b) und (c/d) zu vergleichen, werden sie zunaechst auf einen +// gemeinsamen Nenner gebracht (b*d), um dann die beiden Zaehler (a*d) +// und (c*b) zu vergleichen. Das Ergebnis dieses Vergleichs wird +// zurueckgegeben. + +BOOL operator > ( const Fraction& rVal1, const Fraction& rVal2 ) +{ + if ( !rVal1.IsValid() || !rVal2.IsValid() ) + return FALSE; + + BigInt nN( rVal1.nNumerator ); + nN *= BigInt( rVal2.nDenominator ); + BigInt nD( rVal1.nDenominator); + nD *= BigInt( rVal2.nNumerator ); + + return nN > nD; +} + +/************************************************************************* +|* +|* SvStream& operator>>( SvStream& rIStream, Fraction& rFract ) +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung MM 08.01.96 +|* Letzte Aenderung MM 08.01.96 +|* +*************************************************************************/ +SvStream& operator >> ( SvStream& rIStream, Fraction& rFract ) +{ + rIStream >> rFract.nNumerator; + rIStream >> rFract.nDenominator; + return rIStream; +} + +/************************************************************************* +|* +|* SvStream& operator<<( SvStream& rIStream, Fraction& rFract ) +|* +|* Beschreibung FRACT.SDW +|* Ersterstellung MM 08.01.96 +|* Letzte Aenderung MM 08.01.96 +|* +*************************************************************************/ +SvStream& operator << ( SvStream& rOStream, const Fraction& rFract ) +{ + rOStream << rFract.nNumerator; + rOStream << rFract.nDenominator; + return rOStream; +} diff --git a/tools/source/generic/gen.cxx b/tools/source/generic/gen.cxx new file mode 100644 index 000000000000..3b340a558a3d --- /dev/null +++ b/tools/source/generic/gen.cxx @@ -0,0 +1,699 @@ +/************************************************************************* + * + * $RCSfile: gen.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _TOOLS_DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _SV_GEN_HXX +#include <gen.hxx> +#endif +#ifndef _STREAM_HXX +#include <stream.hxx> +#endif + +// ======================================================================= + +SvStream& operator>>( SvStream& rIStream, Pair& rPair ) +{ + DBG_ASSERTWARNING( rIStream.GetVersion(), "Pair::>> - Solar-Version not set on rIStream" ); + + if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cId; + unsigned char cAry[8]; + int i; + int i1; + int i2; + UINT32 nNum; + + rIStream >> cId; + i1 = (cId & 0x70) >> 4; + i2 = cId & 0x07; + rIStream.Read( cAry, i1+i2 ); + + nNum = 0; + i = i1; + while ( i ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + if ( cId & 0x80 ) + nNum ^= 0xFFFFFFFF; + rPair.nA = (INT32)nNum; + + nNum = 0; + i = i1+i2; + while ( i > i1 ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + if ( cId & 0x08 ) + nNum ^= 0xFFFFFFFF; + rPair.nB = (INT32)nNum; + } + else + { + rIStream >> rPair.nA >> rPair.nB; + } + + return rIStream; +} + +// ----------------------------------------------------------------------- + +SvStream& operator<<( SvStream& rOStream, const Pair& rPair ) +{ + DBG_ASSERTWARNING( rOStream.GetVersion(), "Pair::<< - Solar-Version not set on rOStream" ); + + if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cAry[9]; + int i = 1; + UINT32 nNum; + + cAry[0] = 0; + + nNum = (UINT32)(INT32)rPair.nA; + if ( rPair.nA < 0 ) + { + cAry[0] |= 0x80; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[0] |= 0x40; + } + else + cAry[0] |= 0x30; + } + else + cAry[0] |= 0x20; + } + else + cAry[0] |= 0x10; + } + + nNum = (UINT32)(INT32)rPair.nB; + if ( rPair.nB < 0 ) + { + cAry[0] |= 0x08; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[0] |= 0x04; + } + else + cAry[0] |= 0x03; + } + else + cAry[0] |= 0x02; + } + else + cAry[0] |= 0x01; + } + + rOStream.Write( cAry, i ); + } + else + { + rOStream << rPair.nA << rPair.nB; + } + + return rOStream; +} + +/************************************************************************* +|* +|* Rectangle::SetSize() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung DV 29.10.91 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +void Rectangle::SetSize( const Size& rSize ) +{ + if ( rSize.Width() < 0 ) + nRight = nLeft + rSize.Width() +1; + else if ( rSize.Width() > 0 ) + nRight = nLeft + rSize.Width() -1; + else + nRight = RECT_EMPTY; + + if ( rSize.Height() < 0 ) + nBottom = nTop + rSize.Height() +1; + else if ( rSize.Height() > 0 ) + nBottom = nTop + rSize.Height() -1; + else + nBottom = RECT_EMPTY; +} + +/************************************************************************* +|* +|* Rectangle::Union() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung TH 20.10.92 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +Rectangle& Rectangle::Union( const Rectangle& rRect ) +{ + if ( rRect.IsEmpty() ) + return *this; + + if ( IsEmpty() ) + *this = rRect; + else + { + nLeft = Min( Min( nLeft, rRect.nLeft ), Min( nRight, rRect.nRight ) ); + nRight = Max( Max( nLeft, rRect.nLeft ), Max( nRight, rRect.nRight ) ); + nTop = Min( Min( nTop, rRect.nTop ), Min( nBottom, rRect.nBottom ) ); + nBottom = Max( Max( nTop, rRect.nTop ), Max( nBottom, rRect.nBottom ) ); + } + + return *this; +} + +/************************************************************************* +|* +|* Rectangle::Intersection() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung TH 20.10.92 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +Rectangle& Rectangle::Intersection( const Rectangle& rRect ) +{ + if ( IsEmpty() ) + return *this; + if ( rRect.IsEmpty() ) + { + *this = Rectangle(); + return *this; + } + + // nicht mit umgedrehten Rechtecken arbeiten + Rectangle aTmpRect( rRect ); + Justify(); + aTmpRect.Justify(); + + // Schnitt bilden + nLeft = Max( nLeft, aTmpRect.nLeft ); + nRight = Min( nRight, aTmpRect.nRight ); + nTop = Max( nTop, aTmpRect.nTop ); + nBottom= Min( nBottom, aTmpRect.nBottom ); + + // Feststellen ob Schnitt leer + if ( nRight < nLeft || nBottom < nTop ) + *this = Rectangle(); + + return *this; +} + +/************************************************************************* +|* +|* Rectangle::Justify() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung DV 07.03.91 +|* Letzte Aenderung DV 07.03.91 +|* +*************************************************************************/ + +void Rectangle::Justify() +{ + long nHelp; + + // Abfrage, ob Right kleiner Left + if ( (nRight < nLeft) && (nRight != RECT_EMPTY) ) + { + nHelp = nLeft; + nLeft = nRight; + nRight = nHelp; + } + + // Abfrage, ob Bottom kleiner Top + if ( (nBottom < nTop) && (nBottom != RECT_EMPTY) ) + { + nHelp = nBottom; + nBottom = nTop; + nTop = nHelp; + } +} + +/************************************************************************* +|* +|* Rectangle::IsInside() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung TH 19.03.90 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +BOOL Rectangle::IsInside( const Point& rPoint ) const +{ + if ( IsEmpty() ) + return FALSE; + + BOOL bRet = TRUE; + if ( nLeft <= nRight ) + { + if ( (rPoint.X() < nLeft) || (rPoint.X() > nRight) ) + bRet = FALSE; + } + else + { + if ( (rPoint.X() > nLeft) || (rPoint.X() < nRight) ) + bRet = FALSE; + } + if ( nTop <= nBottom ) + { + if ( (rPoint.Y() < nTop) || (rPoint.Y() > nBottom) ) + bRet = FALSE; + } + else + { + if ( (rPoint.Y() > nTop) || (rPoint.Y() < nBottom) ) + bRet = FALSE; + } + return bRet; +} + +/************************************************************************* +|* +|* Rectangle::IsInside() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung TH 19.03.90 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +BOOL Rectangle::IsInside( const Rectangle& rRect ) const +{ + if ( IsInside( rRect.TopLeft() ) && IsInside( rRect.BottomRight() ) ) + return TRUE; + else + return FALSE; +} + +/************************************************************************* +|* +|* Rectangle::IsOver() +|* +|* Beschreibung GEN.SDW +|* Ersterstellung TH 19.03.90 +|* Letzte Aenderung MM 21.04.94 +|* +*************************************************************************/ + +BOOL Rectangle::IsOver( const Rectangle& rRect ) const +{ + // Wenn sie sich nicht schneiden, ueberlappen sie auch nicht + return !GetIntersection( rRect ).IsEmpty(); +} + +// ======================================================================= + +SvStream& operator>>( SvStream& rIStream, Rectangle& rRect ) +{ + DBG_ASSERTWARNING( rIStream.GetVersion(), "Rectangle::>> - Solar-Version not set on rIStream" ); + + if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cIdAry[2]; + unsigned char cAry[16]; + int i; + int iLast; + int i1; + int i2; + int i3; + int i4; + UINT32 nNum; + + rIStream.Read( cIdAry, 2 ); + i1 = (cIdAry[0] & 0x70) >> 4; + i2 = cIdAry[0] & 0x07; + i3 = (cIdAry[1] & 0x70) >> 4; + i4 = cIdAry[1] & 0x07; + rIStream.Read( cAry, i1+i2+i3+i4 ); + + nNum = 0; + i = i1; + iLast = i; + while ( i ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + iLast = i1; + if ( cIdAry[0] & 0x80 ) + nNum ^= 0xFFFFFFFF; + rRect.nLeft = (INT32)nNum; + + nNum = 0; + i = iLast+i2; + while ( i > iLast ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + iLast += i2; + if ( cIdAry[0] & 0x08 ) + nNum ^= 0xFFFFFFFF; + rRect.nTop = (INT32)nNum; + + nNum = 0; + i = iLast+i3; + while ( i > iLast ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + iLast += i3; + if ( cIdAry[1] & 0x80 ) + nNum ^= 0xFFFFFFFF; + rRect.nRight = (INT32)nNum; + + nNum = 0; + i = iLast+i4; + while ( i > iLast ) + { + i--; + nNum <<= 8; + nNum |= cAry[i]; + } + if ( cIdAry[1] & 0x08 ) + nNum ^= 0xFFFFFFFF; + rRect.nBottom = (INT32)nNum; + } + else + { + rIStream >> rRect.nLeft >> rRect.nTop >> rRect.nRight >> rRect.nBottom; + } + + return rIStream; +} + +// ----------------------------------------------------------------------- + +SvStream& operator<<( SvStream& rOStream, const Rectangle& rRect ) +{ + DBG_ASSERTWARNING( rOStream.GetVersion(), "Rectangle::<< - Solar-Version not set on rOStream" ); + + if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL ) + { + unsigned char cAry[18]; + int i = 2; + UINT32 nNum; + + cAry[0] = 0; + cAry[1] = 0; + + nNum = (UINT32)(INT32)rRect.nLeft; + if ( rRect.nLeft < 0 ) + { + cAry[0] |= 0x80; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[0] |= 0x40; + } + else + cAry[0] |= 0x30; + } + else + cAry[0] |= 0x20; + } + else + cAry[0] |= 0x10; + } + + nNum = (UINT32)(INT32)rRect.nTop; + if ( rRect.nTop < 0 ) + { + cAry[0] |= 0x08; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[0] |= 0x04; + } + else + cAry[0] |= 0x03; + } + else + cAry[0] |= 0x02; + } + else + cAry[0] |= 0x01; + } + + nNum = (UINT32)(INT32)rRect.nRight; + if ( rRect.nRight < 0 ) + { + cAry[1] |= 0x80; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[1] |= 0x40; + } + else + cAry[1] |= 0x30; + } + else + cAry[1] |= 0x20; + } + else + cAry[1] |= 0x10; + } + + nNum = (UINT32)(INT32)rRect.nBottom; + if ( rRect.nBottom < 0 ) + { + cAry[1] |= 0x08; + nNum ^= 0xFFFFFFFF; + } + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + + if ( nNum ) + { + cAry[i] = (unsigned char)(nNum & 0xFF); + nNum >>= 8; + i++; + cAry[1] |= 0x04; + } + else + cAry[1] |= 0x03; + } + else + cAry[1] |= 0x02; + } + else + cAry[1] |= 0x01; + } + + rOStream.Write( cAry, i ); + } + else + { + rOStream << rRect.nLeft << rRect.nTop << rRect.nRight << rRect.nBottom; + } + + return rOStream; +} diff --git a/tools/source/generic/link.cxx b/tools/source/generic/link.cxx new file mode 100644 index 000000000000..33248d3363cd --- /dev/null +++ b/tools/source/generic/link.cxx @@ -0,0 +1,92 @@ +/************************************************************************* + * + * $RCSfile: link.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _LINK_HXX +#include <link.hxx> +#endif + +/************************************************************************* +|* +|* Link::operator==() +|* +|* Beschreibung LINK.SDW +|* Ersterstellung AM 14.02.91 +|* Letzte Aenderung TH 07.11.95 +|* +*************************************************************************/ + +BOOL Link::operator==( const Link& rLink ) const +{ + if ( pFunc == rLink.pFunc ) + { + if ( pFunc ) + { + if ( pInst == rLink.pInst ) + return TRUE; + else + return FALSE; + } + else + return TRUE; + } + else + return FALSE; +} diff --git a/tools/source/generic/makefile.mk b/tools/source/generic/makefile.mk new file mode 100644 index 000000000000..6b6ce0d86eef --- /dev/null +++ b/tools/source/generic/makefile.mk @@ -0,0 +1,98 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=gen + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/toolsin.obj \ + $(SLO)$/link.obj \ + $(SLO)$/bigint.obj \ + $(SLO)$/fract.obj \ + $(SLO)$/solmath.obj \ + $(SLO)$/color.obj \ + $(SLO)$/l2txtenc.obj \ + $(SLO)$/gen.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/toolsin.obj \ + $(OBJ)$/link.obj \ + $(OBJ)$/bigint.obj \ + $(OBJ)$/fract.obj \ + $(OBJ)$/solmath.obj \ + $(OBJ)$/color.obj \ + $(OBJ)$/l2txtenc.obj \ + $(OBJ)$/gen.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/generic/toolsin.cxx b/tools/source/generic/toolsin.cxx new file mode 100644 index 000000000000..b37e14321d9e --- /dev/null +++ b/tools/source/generic/toolsin.cxx @@ -0,0 +1,159 @@ +/************************************************************************* + * + * $RCSfile: toolsin.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _TOOLS_TOOLSIN_CXX + +#include <string.h> + +#ifndef _SHL_HXX +#include <shl.hxx> +#endif + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _INTNTAB_HXX +#include <intntab.hxx> +#endif +#ifndef _TOOLSIN_HXX +#include <toolsin.hxx> +#endif + +#if defined( WIN ) || defined( WNT ) || defined( OS2 ) +#include <dll.hxx> +#endif +#ifdef MAC +void ImpDeInitMemMgr(); +#endif + +void ImplDeleteCharTabData(); + +// ======================================================================= + +// Hier drin, da DOS bisher kein eigenes TOOLS-Verzeichnis hat + +#if defined( DOS ) + +static void* aAppData[SHL_COUNT]; + +void** GetAppData( USHORT nSharedLib ) +{ + return &(aAppData[nSharedLib]); +} + +#endif + +// ======================================================================= + +TOOLSINDATA* ImplGetToolsInData() +{ + TOOLSINDATA** ppData = (TOOLSINDATA**)GetAppData( SHL_TOOLS ); + if ( !(*ppData) ) + { + TOOLSINDATA* pData = new TOOLSINDATA; + memset( pData, 0, sizeof( TOOLSINDATA ) ); + *ppData = pData; + } + + return *ppData; +} + +// ======================================================================= + +void InitTools() +{ + DBG_DEBUGSTART(); +} + +// ----------------------------------------------------------------------- + +void DeInitTools() +{ + TOOLSINDATA** ppData = (TOOLSINDATA**)GetAppData( SHL_TOOLS ); + TOOLSINDATA* pData = *ppData; + + if ( pData ) + { + ImplDeleteIntnListData(); + ImplDeleteCharTabData(); + delete pData; + *ppData = NULL; + } + + DBG_DEBUGEND(); +} + +// ----------------------------------------------------------------------- + +void GlobalDeInitTools() +{ + DBG_GLOBALDEBUGEND(); + +#if defined( WIN ) || defined( WNT ) + ImpDeInitWinTools(); +#endif +#ifdef OS2 + ImpDeInitOS2Tools(); +#endif +#ifdef MAC + ImpDeInitMemMgr(); +#endif +} diff --git a/tools/source/inet/inetmime.cxx b/tools/source/inet/inetmime.cxx new file mode 100644 index 000000000000..a1d70a045222 --- /dev/null +++ b/tools/source/inet/inetmime.cxx @@ -0,0 +1,4630 @@ +/************************************************************************* + * + * $RCSfile: inetmime.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <limits> + +#ifndef _DATETIME_HXX +#include <datetime.hxx> +#endif +#ifndef TOOLS_INETMIME_HXX +#include <inetmime.hxx> +#endif + +#undef max // defined by <tools/solar.h> +#undef min // defined by <tools/solar.h> + +namespace unnamed_tools_inetmime {} using namespace unnamed_tools_inetmime; + // unnamed namespaces don't work well yet + +//============================================================================ +namespace unnamed_tools_inetmime { + +class Charset +{ + rtl_TextEncoding m_eEncoding; + const sal_uInt32 * m_pRanges; + +public: + inline Charset(rtl_TextEncoding eTheEncoding, + const sal_uInt32 * pTheRanges); + + rtl_TextEncoding getEncoding() const { return m_eEncoding; } + + bool contains(sal_uInt32 nChar) const; +}; + +inline Charset::Charset(rtl_TextEncoding eTheEncoding, + const sal_uInt32 * pTheRanges): + m_eEncoding(eTheEncoding), + m_pRanges(pTheRanges) +{ + DBG_ASSERT(m_pRanges, "Charset::Charset(): Bad ranges"); +} + +//============================================================================ +void appendISO88591(UniString & rText, sal_Char const * pBegin, + sal_Char const * pEnd); + +} + +//============================================================================ +class INetMIMECharsetList_Impl +{ + struct Node + { + Charset m_aCharset; + bool m_bDisabled; + Node * m_pNext; + + inline Node(const Charset & rTheCharset, bool bTheDisabled, + Node * pTheNext); + }; + + Node * m_pFirst; + +public: + INetMIMECharsetList_Impl(): m_pFirst(0) {} + + ~INetMIMECharsetList_Impl(); + + void prepend(const Charset & rCharset) + { m_pFirst = new Node(rCharset, false, m_pFirst); } + + void includes(sal_uInt32 nChar); + + rtl_TextEncoding getPreferredEncoding(rtl_TextEncoding eDefault + = RTL_TEXTENCODING_DONTKNOW) + const; + + void reset(); +}; + +inline INetMIMECharsetList_Impl::Node::Node(const Charset & rTheCharset, + bool bTheDisabled, + Node * pTheNext): + m_aCharset(rTheCharset), + m_bDisabled(bTheDisabled), + m_pNext(pTheNext) +{} + +//============================================================================ +namespace unnamed_tools_inetmime { + +struct Parameter +{ + Parameter * m_pNext; + ByteString m_aAttribute; + ByteString m_aCharset; + ByteString m_aLanguage; + ByteString m_aValue; + sal_uInt32 m_nSection; + bool m_bExtended; + + inline Parameter(Parameter * pTheNext, ByteString const & rTheAttribute, + ByteString const & rTheCharset, + ByteString const & rTheLanguage, + ByteString const & rTheValue, sal_uInt32 nTheSection, + bool bTheExtended); +}; + +inline Parameter::Parameter(Parameter * pTheNext, + ByteString const & rTheAttribute, + ByteString const & rTheCharset, + ByteString const & rTheLanguage, + ByteString const & rTheValue, + sal_uInt32 nTheSection, bool bTheExtended): + m_pNext(pTheNext), + m_aAttribute(rTheAttribute), + m_aCharset(rTheCharset), + m_aLanguage(rTheLanguage), + m_aValue(rTheValue), + m_nSection(nTheSection), + m_bExtended(bTheExtended) +{} + +//============================================================================ +struct ParameterList +{ + Parameter * m_pList; + + ParameterList(): m_pList(0) {} + + inline ~ParameterList(); + + Parameter ** find(ByteString const & rAttribute, sal_uInt32 nSection, + bool & rPresent); +}; + +inline ParameterList::~ParameterList() +{ + while (m_pList) + { + Parameter * pNext = m_pList->m_pNext; + delete m_pList; + m_pList = pNext; + } +} + +//============================================================================ +bool parseParameters(ParameterList const & rInput, + INetContentTypeParameterList * pOutput); + +} + +//============================================================================ +// +// Charset +// +//============================================================================ + +bool Charset::contains(sal_uInt32 nChar) const +{ + for (const sal_uInt32 * p = m_pRanges;;) + { + if (nChar < *p++) + return false; + if (nChar <= *p++) + return true; + } +} + +//============================================================================ +// +// appendISO88591 +// +//============================================================================ + +namespace unnamed_tools_inetmime { + +void appendISO88591(UniString & rText, sal_Char const * pBegin, + sal_Char const * pEnd) +{ + sal_Size nLength = pEnd - pBegin; + sal_Unicode * pBuffer = new sal_Unicode[nLength]; + for (sal_Unicode * p = pBuffer; pBegin != pEnd;) + *p++ = sal_uChar(*pBegin++); + rText.Append(pBuffer, nLength); + delete[] pBuffer; +} + +} + +//============================================================================ +// +// INetMIMECharsetList_Impl +// +//============================================================================ + +INetMIMECharsetList_Impl::~INetMIMECharsetList_Impl() +{ + while (m_pFirst) + { + Node * pRemove = m_pFirst; + m_pFirst = m_pFirst->m_pNext; + delete pRemove; + } +} + +//============================================================================ +void INetMIMECharsetList_Impl::includes(sal_uInt32 nChar) +{ + for (Node * p = m_pFirst; p; p = p->m_pNext) + if (!(p->m_bDisabled || p->m_aCharset.contains(nChar))) + p->m_bDisabled = true; +} + +//============================================================================ +rtl_TextEncoding +INetMIMECharsetList_Impl::getPreferredEncoding(rtl_TextEncoding eDefault) + const +{ + for (Node * p = m_pFirst; p; p = p->m_pNext) + if (!p->m_bDisabled) + return p->m_aCharset.getEncoding(); + return eDefault; +} + +//============================================================================ +void INetMIMECharsetList_Impl::reset() +{ + for (Node * p = m_pFirst; p; p = p->m_pNext) + p->m_bDisabled = false; +} + +//============================================================================ +// +// ParameterList +// +//============================================================================ + +Parameter ** ParameterList::find(ByteString const & rAttribute, + sal_uInt32 nSection, bool & rPresent) +{ + Parameter ** p = &m_pList; + for (; *p; p = &(*p)->m_pNext) + { + StringCompare eCompare = rAttribute.CompareTo((*p)->m_aAttribute); + if (eCompare == COMPARE_GREATER) + break; + else if (eCompare == COMPARE_EQUAL) + if (nSection > (*p)->m_nSection) + break; + else if (nSection == (*p)->m_nSection) + { + rPresent = true; + return p; + } + } + rPresent = false; + return p; +} + +//============================================================================ +// +// parseParameters +// +//============================================================================ + +namespace unnamed_tools_inetmime { + +bool parseParameters(ParameterList const & rInput, + INetContentTypeParameterList * pOutput) +{ + if (pOutput) + pOutput->Clear(); + + Parameter * pPrev = 0; + for (Parameter * p = rInput.m_pList; p; p = p->m_pNext) + { + if (p->m_nSection > 0 + && (!pPrev + || pPrev->m_nSection != p->m_nSection - 1 + || pPrev->m_aAttribute != p->m_aAttribute)) + return false; + pPrev = p; + } + + if (pOutput) + for (Parameter * p = rInput.m_pList; p;) + { + bool bCharset = p->m_aCharset.Len() != 0; + rtl_TextEncoding eEncoding; + if (bCharset) + eEncoding + = INetMIME::getCharsetEncoding(p->m_aCharset.GetBuffer(), + p->m_aCharset.GetBuffer() + + rInput.m_pList-> + m_aCharset. + Len()); + UniString aValue; + bool bBadEncoding = false; + Parameter * pNext = p; + do + { + sal_Size nSize; + sal_Unicode * pUnicode + = INetMIME::convertToUnicode(pNext->m_aValue.GetBuffer(), + pNext->m_aValue.GetBuffer() + + pNext->m_aValue.Len(), + bCharset && p->m_bExtended ? + eEncoding : + RTL_TEXTENCODING_UTF8, + nSize); + if (!pUnicode && !(bCharset && p->m_bExtended)) + pUnicode = INetMIME::convertToUnicode( + pNext->m_aValue.GetBuffer(), + pNext->m_aValue.GetBuffer() + + pNext->m_aValue.Len(), + RTL_TEXTENCODING_ISO_8859_1, nSize); + if (!pUnicode) + { + bBadEncoding = true; + break; + } + aValue += UniString(pUnicode, nSize); + delete[] pUnicode; + pNext = pNext->m_pNext; + } + while (pNext && pNext->m_nSection > 0); + if (bBadEncoding) + { + aValue.Erase(); + for (pNext = p;;) + { + if (pNext->m_bExtended) + for (xub_StrLen i = 0; i < pNext->m_aValue.Len(); ++i) + aValue + += sal_Unicode(sal_uChar + (pNext-> + m_aValue.GetChar(i))) + | 0xF800; + else + for (xub_StrLen i = 0; i < pNext->m_aValue.Len(); ++i) + aValue + += sal_Unicode(sal_uChar + (pNext-> + m_aValue.GetChar(i))); + pNext = pNext->m_pNext; + if (!pNext || pNext->m_nSection == 0) + break; + }; + } + pOutput->Insert(new INetContentTypeParameter(p->m_aAttribute, + p->m_aCharset, + p->m_aLanguage, + aValue, + !bBadEncoding), + LIST_APPEND); + p = pNext; + } + return true; +} + +} + +//============================================================================ +// +// INetMIME +// +//============================================================================ + +// static +bool INetMIME::isAtomChar(sal_uInt32 nChar) +{ + static const bool aMap[128] + = { false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, true, false, true, true, true, true, true, // !"#$%&' + false, false, true, true, false, true, false, true, //()*+,-./ + true, true, true, true, true, true, true, true, //01234567 + true, true, false, false, false, true, false, true, //89:;<=>? + false, true, true, true, true, true, true, true, //@ABCDEFG + true, true, true, true, true, true, true, true, //HIJKLMNO + true, true, true, true, true, true, true, true, //PQRSTUVW + true, true, true, false, false, false, true, true, //XYZ[\]^_ + true, true, true, true, true, true, true, true, //`abcdefg + true, true, true, true, true, true, true, true, //hijklmno + true, true, true, true, true, true, true, true, //pqrstuvw + true, true, true, true, true, true, true, false //xyz{|}~ + }; + return isUSASCII(nChar) && aMap[nChar]; +} + +//============================================================================ +// static +bool INetMIME::isTokenChar(sal_uInt32 nChar) +{ + static const sal_Char aMap[128] + = { false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, true, false, true, true, true, true, true, // !"#$%&' + false, false, true, true, false, true, true, false, //()*+,-./ + true, true, true, true, true, true, true, true, //01234567 + true, true, false, false, false, false, false, false, //89:;<=>? + false, true, true, true, true, true, true, true, //@ABCDEFG + true, true, true, true, true, true, true, true, //HIJKLMNO + true, true, true, true, true, true, true, true, //PQRSTUVW + true, true, true, false, false, false, true, true, //XYZ[\]^_ + true, true, true, true, true, true, true, true, //`abcdefg + true, true, true, true, true, true, true, true, //hijklmno + true, true, true, true, true, true, true, true, //pqrstuvw + true, true, true, true, true, true, true, false //xyz{|}~ + }; + return isUSASCII(nChar) && aMap[nChar]; +} + +//============================================================================ +// static +bool INetMIME::isEncodedWordTokenChar(sal_uInt32 nChar) +{ + static const sal_Char aMap[128] + = { false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, true, false, true, true, true, true, true, // !"#$%&' + false, false, true, true, false, true, false, false, //()*+,-./ + true, true, true, true, true, true, true, true, //01234567 + true, true, false, false, false, false, false, false, //89:;<=>? + false, true, true, true, true, true, true, true, //@ABCDEFG + true, true, true, true, true, true, true, true, //HIJKLMNO + true, true, true, true, true, true, true, true, //PQRSTUVW + true, true, true, false, false, false, true, true, //XYZ[\]^_ + true, true, true, true, true, true, true, true, //`abcdefg + true, true, true, true, true, true, true, true, //hijklmno + true, true, true, true, true, true, true, true, //pqrstuvw + true, true, true, true, true, true, true, false //xyz{|}~ + }; + return isUSASCII(nChar) && aMap[nChar]; +} + +//============================================================================ +// static +bool INetMIME::isIMAPAtomChar(sal_uInt32 nChar) +{ + static const sal_Char aMap[128] + = { false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, + false, true, false, true, true, false, true, true, // !"#$%&' + false, false, false, true, true, true, true, true, //()*+,-./ + true, true, true, true, true, true, true, true, //01234567 + true, true, true, true, true, true, true, true, //89:;<=>? + true, true, true, true, true, true, true, true, //@ABCDEFG + true, true, true, true, true, true, true, true, //HIJKLMNO + true, true, true, true, true, true, true, true, //PQRSTUVW + true, true, true, true, false, true, true, true, //XYZ[\]^_ + true, true, true, true, true, true, true, true, //`abcdefg + true, true, true, true, true, true, true, true, //hijklmno + true, true, true, true, true, true, true, true, //pqrstuvw + true, true, true, false, true, true, true, false //xyz{|}~ + }; + return isUSASCII(nChar) && aMap[nChar]; +} + +//============================================================================ +// static +sal_uInt32 INetMIME::getDigit(int nWeight) +{ + DBG_ASSERT(nWeight >= 0 && nWeight < 10, + "INetMIME::getDigit(): Bad weight"); + + static const sal_Char aDigits[16] + = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; + return aDigits[nWeight]; +} + +//============================================================================ +// static +sal_uInt32 INetMIME::getHexDigit(int nWeight) +{ + DBG_ASSERT(nWeight >= 0 && nWeight < 16, + "INetMIME::getHexDigit(): Bad weight"); + + static const sal_Char aDigits[16] + = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', + 'D', 'E', 'F' }; + return aDigits[nWeight]; +} + +//============================================================================ +// static +sal_uInt32 INetMIME::getBase64Digit(int nWeight) +{ + DBG_ASSERT(nWeight >= 0 && nWeight < 64, + "INetMIME::getBase64Digit(): Bad weight"); + + static const sal_Char aDigits[64] + = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', + 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' }; + return aDigits[nWeight]; +} + +//============================================================================ +// static +bool INetMIME::equalIgnoreCase(const sal_Char * pBegin1, + const sal_Char * pEnd1, + const sal_Char * pBegin2, + const sal_Char * pEnd2) +{ + DBG_ASSERT(pBegin1 && pBegin1 <= pEnd1 && pBegin2 && pBegin2 <= pEnd2, + "INetMIME::equalIgnoreCase(): Bad sequences"); + + if (pEnd1 - pBegin1 != pEnd2 - pBegin2) + return false; + while (pBegin1 != pEnd1) + if (toUpperCase(*pBegin1++) != toUpperCase(*pBegin2++)) + return false; + return true; +} + +//============================================================================ +// static +bool INetMIME::equalIgnoreCase(const sal_Char * pBegin1, + const sal_Char * pEnd1, + const sal_Char * pString2) +{ + DBG_ASSERT(pBegin1 && pBegin1 <= pEnd1 && pString2, + "INetMIME::equalIgnoreCase(): Bad sequences"); + + while (*pString2 != 0) + if (pBegin1 == pEnd1 + || toUpperCase(*pBegin1++) != toUpperCase(*pString2++)) + return false; + return pBegin1 == pEnd1; +} + +//============================================================================ +// static +bool INetMIME::equalIgnoreCase(const sal_Unicode * pBegin1, + const sal_Unicode * pEnd1, + const sal_Char * pString2) +{ + DBG_ASSERT(pBegin1 && pBegin1 <= pEnd1 && pString2, + "INetMIME::equalIgnoreCase(): Bad sequences"); + + while (*pString2 != 0) + if (pBegin1 == pEnd1 + || toUpperCase(*pBegin1++) != toUpperCase(*pString2++)) + return false; + return pBegin1 == pEnd1; +} + +//============================================================================ +// static +const sal_Char * INetMIME::skipLinearWhiteSpace(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipLinearWhiteSpace(): Bad sequence"); + + while (pBegin != pEnd) + switch (*pBegin) + { + case '\t': + case ' ': + ++pBegin; + break; + + case 0x0D: // CR + if (startsWithLineFolding(pBegin, pEnd)) + pBegin += 3; + else + return pBegin; + break; + + default: + return pBegin; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::skipLinearWhiteSpace(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipLinearWhiteSpace(): Bad sequence"); + + while (pBegin != pEnd) + switch (*pBegin) + { + case '\t': + case ' ': + ++pBegin; + break; + + case 0x0D: // CR + if (startsWithLineFolding(pBegin, pEnd)) + pBegin += 3; + else + return pBegin; + break; + + default: + return pBegin; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Char * INetMIME::skipComment(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipComment(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == '(') + { + sal_uInt32 nLevel = 0; + for (const sal_Char * p = pBegin; p != pEnd;) + switch (*p++) + { + case '(': + ++nLevel; + break; + + case ')': + if (--nLevel == 0) + return p; + break; + + case '\\': + if (p != pEnd) + ++p; + break; + } + } + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::skipComment(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipComment(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == '(') + { + sal_uInt32 nLevel = 0; + for (const sal_Unicode * p = pBegin; p != pEnd;) + switch (*p++) + { + case '(': + ++nLevel; + break; + + case ')': + if (--nLevel == 0) + return p; + break; + + case '\\': + if (p != pEnd) + ++p; + break; + } + } + return pBegin; +} + +//============================================================================ +// static +const sal_Char * INetMIME::skipLinearWhiteSpaceComment(const sal_Char * + pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipLinearWhiteSpaceComment(): Bad sequence"); + + while (pBegin != pEnd) + switch (*pBegin) + { + case '\t': + case ' ': + ++pBegin; + break; + + case 0x0D: // CR + if (startsWithLineFolding(pBegin, pEnd)) + pBegin += 3; + else + return pBegin; + break; + + case '(': + { + const sal_Char * p = skipComment(pBegin, pEnd); + if (p == pBegin) + return pBegin; + pBegin = p; + break; + } + + default: + return pBegin; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::skipLinearWhiteSpaceComment(const sal_Unicode * + pBegin, + const sal_Unicode * + pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipLinearWhiteSpaceComment(): Bad sequence"); + + while (pBegin != pEnd) + switch (*pBegin) + { + case '\t': + case ' ': + ++pBegin; + break; + + case 0x0D: // CR + if (startsWithLineFolding(pBegin, pEnd)) + pBegin += 3; + else + return pBegin; + break; + + case '(': + { + const sal_Unicode * p = skipComment(pBegin, pEnd); + if (p == pBegin) + return pBegin; + pBegin = p; + break; + } + + default: + return pBegin; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Char * INetMIME::skipQuotedString(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipQuotedString(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == '"') + for (const sal_Char * p = pBegin + 1; p != pEnd;) + switch (*p++) + { + case 0x0D: // CR + if (pEnd - p < 2 || *p++ != 0x0A // LF + || !isWhiteSpace(*p++)) + return pBegin; + break; + + case '"': + return p; + + case '\\': + if (p != pEnd) + ++p; + break; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::skipQuotedString(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::skipQuotedString(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == '"') + for (const sal_Unicode * p = pBegin + 1; p != pEnd;) + switch (*p++) + { + case 0x0D: // CR + if (pEnd - p < 2 || *p++ != 0x0A // LF + || !isWhiteSpace(*p++)) + return pBegin; + break; + + case '"': + return p; + + case '\\': + if (p != pEnd) + ++p; + break; + } + return pBegin; +} + +//============================================================================ +// static +const sal_Char * INetMIME::scanAtom(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + while (pBegin != pEnd && isAtomChar(*pBegin)) + ++pBegin; + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::scanAtom(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + while (pBegin != pEnd && isAtomChar(*pBegin)) + ++pBegin; + return pBegin; +} + +//============================================================================ +// static +bool INetMIME::scanUnsigned(const sal_Char *& rBegin, const sal_Char * pEnd, + bool bLeadingZeroes, sal_uInt32 & rValue) +{ + sal_uInt64 nTheValue = 0; + for (const sal_Char * p = rBegin; p != pEnd; ++p) + { + int nWeight = getWeight(*p); + if (nWeight < 0) + break; + nTheValue = 10 * nTheValue + nWeight; + if (nTheValue > std::numeric_limits< sal_uInt32 >::max()) + return false; + } + if (nTheValue == 0 && (p == rBegin || !bLeadingZeroes && p - rBegin != 1)) + return false; + rBegin = p; + rValue = sal_uInt32(nTheValue); + return true; +} + +//============================================================================ +// static +bool INetMIME::scanUnsigned(const sal_Unicode *& rBegin, + const sal_Unicode * pEnd, bool bLeadingZeroes, + sal_uInt32 & rValue) +{ + sal_uInt64 nTheValue = 0; + for (const sal_Unicode * p = rBegin; p != pEnd; ++p) + { + int nWeight = getWeight(*p); + if (nWeight < 0) + break; + nTheValue = 10 * nTheValue + nWeight; + if (nTheValue > std::numeric_limits< sal_uInt32 >::max()) + return false; + } + if (nTheValue == 0 && (p == rBegin || !bLeadingZeroes && p - rBegin != 1)) + return false; + rBegin = p; + rValue = sal_uInt32(nTheValue); + return true; +} + +//============================================================================ +// static +bool INetMIME::scanUnsignedHex(const sal_Char *& rBegin, + const sal_Char * pEnd, bool bLeadingZeroes, + sal_uInt32 & rValue) +{ + sal_uInt64 nTheValue = 0; + for (const sal_Char * p = rBegin; p != pEnd; ++p) + { + int nWeight = getHexWeight(*p); + if (nWeight < 0) + break; + nTheValue = nTheValue << 4 | nWeight; + if (nTheValue > std::numeric_limits< sal_uInt32 >::max()) + return false; + } + if (nTheValue == 0 && (p == rBegin || !bLeadingZeroes && p - rBegin != 1)) + return false; + rBegin = p; + rValue = sal_uInt32(nTheValue); + return true; +} + +//============================================================================ +// static +bool INetMIME::scanUnsignedHex(const sal_Unicode *& rBegin, + const sal_Unicode * pEnd, bool bLeadingZeroes, + sal_uInt32 & rValue) +{ + sal_uInt64 nTheValue = 0; + for (const sal_Unicode * p = rBegin; p != pEnd; ++p) + { + int nWeight = getHexWeight(*p); + if (nWeight < 0) + break; + nTheValue = nTheValue << 4 | nWeight; + if (nTheValue > std::numeric_limits< sal_uInt32 >::max()) + return false; + } + if (nTheValue == 0 && (p == rBegin || !bLeadingZeroes && p - rBegin != 1)) + return false; + rBegin = p; + rValue = sal_uInt32(nTheValue); + return true; +} + +//============================================================================ +// static +const sal_Char * INetMIME::scanQuotedBlock(const sal_Char * pBegin, + const sal_Char * pEnd, + sal_uInt32 nOpening, + sal_uInt32 nClosing, + sal_uInt32 & rLength, + bool & rModify) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::scanQuotedBlock(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == nOpening) + { + ++rLength; + ++pBegin; + while (pBegin != pEnd) + if (*pBegin == nClosing) + { + ++rLength; + return ++pBegin; + } + else + { + sal_uInt32 c = *pBegin++; + switch (c) + { + case 0x0D: // CR + if (pBegin != pEnd && *pBegin == 0x0A) // LF + if (pEnd - pBegin >= 2 && isWhiteSpace(pBegin[1])) + { + ++rLength; + rModify = true; + pBegin += 2; + } + else + { + rLength += 3; + rModify = true; + ++pBegin; + } + else + ++rLength; + break; + + case '\\': + ++rLength; + if (pBegin != pEnd) + if (startsWithLineBreak(pBegin, pEnd) + && (pEnd - pBegin < 3 + || !isWhiteSpace(pBegin[2]))) + { + rLength += 3; + rModify = true; + pBegin += 2; + } + else + ++pBegin; + break; + + default: + ++rLength; + if (!isUSASCII(c)) + rModify = true; + break; + } + } + } + return pBegin; +} + +//============================================================================ +// static +const sal_Unicode * INetMIME::scanQuotedBlock(const sal_Unicode * pBegin, + const sal_Unicode * pEnd, + sal_uInt32 nOpening, + sal_uInt32 nClosing, + sal_uInt32 & rLength, + bool & rModify) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIME::scanQuotedBlock(): Bad sequence"); + + if (pBegin != pEnd && *pBegin == nOpening) + { + ++rLength; + ++pBegin; + while (pBegin != pEnd) + if (*pBegin == nClosing) + { + ++rLength; + return ++pBegin; + } + else + { + sal_uInt32 c = *pBegin++; + switch (c) + { + case 0x0D: // CR + if (pBegin != pEnd && *pBegin == 0x0A) // LF + if (pEnd - pBegin >= 2 && isWhiteSpace(pBegin[1])) + { + ++rLength; + rModify = true; + pBegin += 2; + } + else + { + rLength += 3; + rModify = true; + ++pBegin; + } + else + ++rLength; + break; + + case '\\': + ++rLength; + if (pBegin != pEnd) + if (startsWithLineBreak(pBegin, pEnd) + && (pEnd - pBegin < 3 + || !isWhiteSpace(pBegin[2]))) + { + rLength += 3; + rModify = true; + pBegin += 2; + } + else + ++pBegin; + break; + + default: + ++rLength; + if (!isUSASCII(c)) + rModify = true; + break; + } + } + } + return pBegin; +} + +//============================================================================ +// static +sal_Char const * INetMIME::scanParameters(sal_Char const * pBegin, + sal_Char const * pEnd, + INetContentTypeParameterList * + pParameters) +{ + ParameterList aList; + sal_Char const * pParameterBegin = pBegin; + for (sal_Char const * p = pParameterBegin;; pParameterBegin = p) + { + pParameterBegin = skipLinearWhiteSpaceComment(p, pEnd); + if (pParameterBegin == pEnd || *pParameterBegin != ';') + break; + p = pParameterBegin + 1; + + sal_Char const * pAttributeBegin = skipLinearWhiteSpaceComment(p, + pEnd); + sal_Char const * p = pAttributeBegin; + bool bDowncaseAttribute = false; + while (p != pEnd && isTokenChar(*p) && *p != '*') + { + bDowncaseAttribute = bDowncaseAttribute || isUpperCase(*p); + ++p; + } + if (p == pAttributeBegin) + break; + ByteString aAttribute(pAttributeBegin, p - pAttributeBegin); + if (bDowncaseAttribute) + aAttribute.ToLowerAscii(); + + sal_uInt32 nSection = 0; + if (p != pEnd && *p == '*') + { + ++p; + if (p != pEnd && isDigit(*p) + && !scanUnsigned(p, pEnd, false, nSection)) + break; + } + + bool bPresent; + Parameter ** pPos = aList.find(aAttribute, nSection, bPresent); + if (bPresent) + break; + + bool bExtended = false; + if (p != pEnd && *p == '*') + { + ++p; + bExtended = true; + } + + p = skipLinearWhiteSpaceComment(p, pEnd); + + if (p == pEnd || *p != '=') + break; + + p = skipLinearWhiteSpaceComment(p + 1, pEnd); + + ByteString aCharset; + ByteString aLanguage; + ByteString aValue; + if (bExtended) + { + if (nSection == 0) + { + sal_Char const * pCharsetBegin = p; + bool bDowncaseCharset = false; + while (p != pEnd && isTokenChar(*p) && *p != '\'') + { + bDowncaseCharset = bDowncaseCharset || isUpperCase(*p); + ++p; + } + if (p == pCharsetBegin) + break; + if (pParameters) + { + aCharset = ByteString(pCharsetBegin, p - pCharsetBegin); + if (bDowncaseCharset) + aCharset.ToLowerAscii(); + } + + if (p == pEnd || *p != '\'') + break; + ++p; + + sal_Char const * pLanguageBegin = p; + bool bDowncaseLanguage = false; + int nLetters = 0; + for (; p != pEnd; ++p) + if (isAlpha(*p)) + { + if (++nLetters > 8) + break; + bDowncaseLanguage = bDowncaseLanguage + || isUpperCase(*p); + } + else if (*p == '-') + { + if (nLetters == 0) + break; + nLetters = 0; + } + else + break; + if (nLetters == 0 || nLetters > 8) + break; + if (pParameters) + { + aLanguage = ByteString(pLanguageBegin, + p - pLanguageBegin); + if (bDowncaseLanguage) + aLanguage.ToLowerAscii(); + } + + if (p == pEnd || *p != '\'') + break; + ++p; + } + if (pParameters) + while (p != pEnd && (isTokenChar(*p) || !isUSASCII(*p))) + { + if (*p == '%') + { + if (p + 2 < pEnd) + { + int nWeight1 = getHexWeight(p[1]); + int nWeight2 = getHexWeight(p[2]); + if (nWeight1 >= 0 && nWeight2 >= 0) + { + aValue += sal_Char(nWeight1 << 4 | nWeight2); + p += 3; + continue; + } + } + } + aValue += *p++; + } + else + while (p != pEnd && (isTokenChar(*p) || !isUSASCII(*p))) + ++p; + } + else if (p != pEnd && *p == '"') + if (pParameters) + { + bool bInvalid = false; + for (++p;;) + { + if (p == pEnd) + { + bInvalid = true; + break; + } + else if (*p == '"') + { + ++p; + break; + } + else if (*p == 0x0D) // CR + { + if (pEnd - p < 3 || p[1] != 0x0A // LF + || !isWhiteSpace(p[2])) + { + bInvalid = true; + break; + } + p += 2; + } + else if (*p == '\\' && ++p == pEnd) + { + bInvalid = true; + break; + } + aValue += *p++; + } + if (bInvalid) + break; + } + else + { + sal_Char const * pStringEnd = skipQuotedString(p, pEnd); + if (p == pStringEnd) + break; + p = pStringEnd; + } + else + { + sal_Char const * pTokenBegin = p; + while (p != pEnd && (isTokenChar(*p) || !isUSASCII(*p))) + ++p; + if (p == pTokenBegin) + break; + if (pParameters) + aValue = ByteString(pTokenBegin, p - pTokenBegin); + } + + *pPos = new Parameter(*pPos, aAttribute, aCharset, aLanguage, aValue, + nSection, bExtended); + } + return parseParameters(aList, pParameters) ? pParameterBegin : pBegin; +} + +//============================================================================ +// static +sal_Unicode const * INetMIME::scanParameters(sal_Unicode const * pBegin, + sal_Unicode const * pEnd, + INetContentTypeParameterList * + pParameters) +{ + ParameterList aList; + sal_Unicode const * pParameterBegin = pBegin; + for (sal_Unicode const * p = pParameterBegin;; pParameterBegin = p) + { + pParameterBegin = skipLinearWhiteSpaceComment(p, pEnd); + if (pParameterBegin == pEnd || *pParameterBegin != ';') + break; + p = pParameterBegin + 1; + + sal_Unicode const * pAttributeBegin + = skipLinearWhiteSpaceComment(p, pEnd); + sal_Unicode const * p = pAttributeBegin; + bool bDowncaseAttribute = false; + while (p != pEnd && isTokenChar(*p) && *p != '*') + { + bDowncaseAttribute = bDowncaseAttribute || isUpperCase(*p); + ++p; + } + if (p == pAttributeBegin) + break; + ByteString aAttribute = ByteString(pAttributeBegin, + p - pAttributeBegin, + RTL_TEXTENCODING_ASCII_US); + if (bDowncaseAttribute) + aAttribute.ToLowerAscii(); + + sal_uInt32 nSection = 0; + if (p != pEnd && *p == '*') + { + ++p; + if (p != pEnd && isDigit(*p) + && !scanUnsigned(p, pEnd, false, nSection)) + break; + } + + bool bPresent; + Parameter ** pPos = aList.find(aAttribute, nSection, bPresent); + if (bPresent) + break; + + bool bExtended = false; + if (p != pEnd && *p == '*') + { + ++p; + bExtended = true; + } + + p = skipLinearWhiteSpaceComment(p, pEnd); + + if (p == pEnd || *p != '=') + break; + + p = skipLinearWhiteSpaceComment(p + 1, pEnd); + + ByteString aCharset; + ByteString aLanguage; + ByteString aValue; + if (bExtended) + { + if (nSection == 0) + { + sal_Unicode const * pCharsetBegin = p; + bool bDowncaseCharset = false; + while (p != pEnd && isTokenChar(*p) && *p != '\'') + { + bDowncaseCharset = bDowncaseCharset || isUpperCase(*p); + ++p; + } + if (p == pCharsetBegin) + break; + if (pParameters) + { + aCharset = ByteString(pCharsetBegin, p - pCharsetBegin, + RTL_TEXTENCODING_ASCII_US); + if (bDowncaseCharset) + aCharset.ToLowerAscii(); + } + + if (p == pEnd || *p != '\'') + break; + ++p; + + sal_Unicode const * pLanguageBegin = p; + bool bDowncaseLanguage = false; + int nLetters = 0; + for (; p != pEnd; ++p) + if (isAlpha(*p)) + { + if (++nLetters > 8) + break; + bDowncaseLanguage = bDowncaseLanguage + || isUpperCase(*p); + } + else if (*p == '-') + { + if (nLetters == 0) + break; + nLetters = 0; + } + else + break; + if (nLetters == 0 || nLetters > 8) + break; + if (pParameters) + { + aLanguage = ByteString(pLanguageBegin, p - pLanguageBegin, + RTL_TEXTENCODING_ASCII_US); + if (bDowncaseLanguage) + aLanguage.ToLowerAscii(); + } + + if (p == pEnd || *p != '\'') + break; + ++p; + } + if (pParameters) + { + INetMIMEStringOutputSink + aSink(0, INetMIMEOutputSink::NO_LINE_LENGTH_LIMIT); + while (p != pEnd) + { + sal_uInt32 nChar = INetMIME::getUTF32Character(p, pEnd); + if (isUSASCII(nChar) && !isTokenChar(nChar)) + break; + if (nChar == '%' && p + 1 < pEnd) + { + int nWeight1 = getHexWeight(p[0]); + int nWeight2 = getHexWeight(p[1]); + if (nWeight1 >= 0 && nWeight2 >= 0) + { + aSink << sal_Char(nWeight1 << 4 | nWeight2); + p += 2; + continue; + } + } + INetMIME::writeUTF8(aSink, nChar); + } + aValue = aSink.takeBuffer(); + } + else + while (p != pEnd && (isTokenChar(*p) || !isUSASCII(*p))) + ++p; + } + else if (p != pEnd && *p == '"') + if (pParameters) + { + INetMIMEStringOutputSink + aSink(0, INetMIMEOutputSink::NO_LINE_LENGTH_LIMIT); + bool bInvalid = false; + for (++p;;) + { + if (p == pEnd) + { + bInvalid = true; + break; + } + sal_uInt32 nChar = INetMIME::getUTF32Character(p, pEnd); + if (nChar == '"') + break; + else if (nChar == 0x0D) // CR + { + if (pEnd - p < 2 || *p++ != 0x0A // LF + || !isWhiteSpace(*p)) + { + bInvalid = true; + break; + } + nChar = sal_uChar(*p++); + } + else if (nChar == '\\') + { + if (p == pEnd) + { + bInvalid = true; + break; + } + nChar = INetMIME::getUTF32Character(p, pEnd); + } + INetMIME::writeUTF8(aSink, nChar); + } + if (bInvalid) + break; + aValue = aSink.takeBuffer(); + } + else + { + sal_Unicode const * pStringEnd = skipQuotedString(p, pEnd); + if (p == pStringEnd) + break; + p = pStringEnd; + } + else + { + sal_Unicode const * pTokenBegin = p; + while (p != pEnd && (isTokenChar(*p) || !isUSASCII(*p))) + ++p; + if (p == pTokenBegin) + break; + if (pParameters) + aValue = ByteString(pTokenBegin, p - pTokenBegin, + RTL_TEXTENCODING_UTF8); + } + + *pPos = new Parameter(*pPos, aAttribute, aCharset, aLanguage, aValue, + nSection, bExtended); + } + return parseParameters(aList, pParameters) ? pParameterBegin : pBegin; +} + +//============================================================================ +// static +const sal_Char * INetMIME::getCharsetName(rtl_TextEncoding eEncoding) +{ + if (eEncoding < RTL_TEXTENCODING_STD_COUNT) + { + // The source for the following table is <ftp://ftp.iana.org/in-notes/ + // iana/assignments/character-sets> as of Jan, 21 2000 12:46:00, + // unless otherwise noted: + static const sal_Char * aMap[RTL_TEXTENCODING_STD_COUNT] + = { 0, // RTL_TEXTENCODING_DONTKNOW + 0, // RTL_TEXTENCODING_MS_1252 + "macintosh", // RTL_TEXTENCODING_APPLE_ROMAN + "IBM437", // RTL_TEXTENCODING_IBM_437 + "IBM850", // RTL_TEXTENCODING_IBM_850 + "IBM860", // RTL_TEXTENCODING_IBM_860 + "IBM861", // RTL_TEXTENCODING_IBM_861 + "IBM863", // RTL_TEXTENCODING_IBM_863 + "IBM865", // RTL_TEXTENCODING_IBM_865 + 0, // CHARSET_SYSTEM + 0, // RTL_TEXTENCODING_SYMBOL + "US-ASCII", // RTL_TEXTENCODING_ASCII_US + "ISO-8859-1", // RTL_TEXTENCODING_ISO_8859_1 + "ISO-8859-2", // RTL_TEXTENCODING_ISO_8859_2 + "ISO-8859-3", // RTL_TEXTENCODING_ISO_8859_3 + "ISO-8859-4", // RTL_TEXTENCODING_ISO_8859_4 + "ISO-8859-5", // RTL_TEXTENCODING_ISO_8859_5 + "ISO-8859-6", // RTL_TEXTENCODING_ISO_8859_6 + "ISO-8859-7", // RTL_TEXTENCODING_ISO_8859_7 + "ISO-8859-8", // RTL_TEXTENCODING_ISO_8859_8 + "ISO-8859-9", // RTL_TEXTENCODING_ISO_8859_9 + "ISO-8859-14", // RTL_TEXTENCODING_ISO_8859_14, RFC 2047 + "ISO_8859-15", // RTL_TEXTENCODING_ISO_8859_15 + 0, // RTL_TEXTENCODING_IBM_737 + "IBM775", // RTL_TEXTENCODING_IBM_775 + "IBM852", // RTL_TEXTENCODING_IBM_852 + "IBM855", // RTL_TEXTENCODING_IBM_855 + "IBM857", // RTL_TEXTENCODING_IBM_857 + "IBM862", // RTL_TEXTENCODING_IBM_862 + "IBM864", // RTL_TEXTENCODING_IBM_864 + "IBM866", // RTL_TEXTENCODING_IBM_866 + "IBM869", // RTL_TEXTENCODING_IBM_869 + 0, // RTL_TEXTENCODING_MS_874 + "windows-1250", // RTL_TEXTENCODING_MS_1250 + "windows-1251", // RTL_TEXTENCODING_MS_1251 + "windows-1253", // RTL_TEXTENCODING_MS_1253 + "windows-1254", // RTL_TEXTENCODING_MS_1254 + "windows-1255", // RTL_TEXTENCODING_MS_1255 + "windows-1256", // RTL_TEXTENCODING_MS_1256 + "windows-1257", // RTL_TEXTENCODING_MS_1257 + "windows-1258", // RTL_TEXTENCODING_MS_1258 + 0, // RTL_TEXTENCODING_APPLE_ARABIC + 0, // RTL_TEXTENCODING_APPLE_CENTEURO + 0, // RTL_TEXTENCODING_APPLE_CROATIAN + 0, // RTL_TEXTENCODING_APPLE_CYRILLIC + 0, // RTL_TEXTENCODING_APPLE_DEVANAGARI + 0, // RTL_TEXTENCODING_APPLE_FARSI + 0, // RTL_TEXTENCODING_APPLE_GREEK + 0, // RTL_TEXTENCODING_APPLE_GUJARATI + 0, // RTL_TEXTENCODING_APPLE_GURMUKHI + 0, // RTL_TEXTENCODING_APPLE_HEBREW + 0, // RTL_TEXTENCODING_APPLE_ICELAND + 0, // RTL_TEXTENCODING_APPLE_ROMANIAN + 0, // RTL_TEXTENCODING_APPLE_THAI + 0, // RTL_TEXTENCODING_APPLE_TURKISH + 0, // RTL_TEXTENCODING_APPLE_UKRAINIAN + 0, // RTL_TEXTENCODING_APPLE_CHINSIMP + 0, // RTL_TEXTENCODING_APPLE_CHINTRAD + 0, // RTL_TEXTENCODING_APPLE_JAPANESE + 0, // RTL_TEXTENCODING_APPLE_KOREAN + 0, // RTL_TEXTENCODING_MS_932 + 0, // RTL_TEXTENCODING_MS_936 + 0, // RTL_TEXTENCODING_MS_949 + 0, // RTL_TEXTENCODING_MS_950 + "Shift_JIS", // RTL_TEXTENCODING_SHIFT_JIS + "GB2312", // RTL_TEXTENCODING_GB_2312 + 0, // RTL_TEXTENCODING_GBT_12345 + 0, // RTL_TEXTENCODING_GBK + "Big5", // RTL_TEXTENCODING_BIG5 + "EUC-JP", // RTL_TEXTENCODING_EUC_JP + 0, // RTL_TEXTENCODING_EUC_CN + 0, // RTL_TEXTENCODING_EUC_TW + "ISO-2022-JP", // RTL_TEXTENCODING_ISO_2022_JP + "ISO-2022-CN", // RTL_TEXTENCODING_ISO_2022_CN + "KOI8-R", // RTL_TEXTENCODING_KOI8_R + "UTF-7", // RTL_TEXTENCODING_UTF7 + "UTF-8", // RTL_TEXTENCODING_UTF8 + "ISO-8859-10", // RTL_TEXTENCODING_ISO_8859_10, RFC 2047 + "ISO-8859-13", // RTL_TEXTENCODING_ISO_8859_13, RFC 2047 + "EUC-KR", // RTL_TEXTENCODING_EUC_KR + "ISO-2022-KR" }; // RTL_TEXTENCODING_ISO_2022_KR + DBG_ASSERT(aMap[eEncoding], + "INetMIME::getCharsetName(): Unsupported encoding"); + return aMap[eEncoding]; + } + else + switch (eEncoding) + { + case RTL_TEXTENCODING_UCS4: + return "ISO-10646-UCS-4"; + + case RTL_TEXTENCODING_UCS2: + return "ISO-10646-UCS-2"; + + default: + DBG_ERROR("INetMIME::getCharsetName(): Unsupported encoding"); + return 0; + } +} + +//============================================================================ +namespace unnamed_tools_inetmime { + +struct EncodingEntry +{ + sal_Char const * m_aName; + rtl_TextEncoding m_eEncoding; +}; + +//============================================================================ +// The source for the following table is <ftp://ftp.iana.org/in-notes/iana/ +// assignments/character-sets> as of Jan, 21 2000 12:46:00, unless otherwise +// noted: +EncodingEntry const aEncodingMap[] + = { { "US-ASCII", RTL_TEXTENCODING_ASCII_US }, + { "ANSI_X3.4-1968", RTL_TEXTENCODING_ASCII_US }, + { "ISO-IR-6", RTL_TEXTENCODING_ASCII_US }, + { "ANSI_X3.4-1986", RTL_TEXTENCODING_ASCII_US }, + { "ISO_646.IRV:1991", RTL_TEXTENCODING_ASCII_US }, + { "ASCII", RTL_TEXTENCODING_ASCII_US }, + { "ISO646-US", RTL_TEXTENCODING_ASCII_US }, + { "US", RTL_TEXTENCODING_ASCII_US }, + { "IBM367", RTL_TEXTENCODING_ASCII_US }, + { "CP367", RTL_TEXTENCODING_ASCII_US }, + { "CSASCII", RTL_TEXTENCODING_ASCII_US }, + { "ISO-8859-1", RTL_TEXTENCODING_ISO_8859_1 }, + { "ISO_8859-1:1987", RTL_TEXTENCODING_ISO_8859_1 }, + { "ISO-IR-100", RTL_TEXTENCODING_ISO_8859_1 }, + { "ISO_8859-1", RTL_TEXTENCODING_ISO_8859_1 }, + { "LATIN1", RTL_TEXTENCODING_ISO_8859_1 }, + { "L1", RTL_TEXTENCODING_ISO_8859_1 }, + { "IBM819", RTL_TEXTENCODING_ISO_8859_1 }, + { "CP819", RTL_TEXTENCODING_ISO_8859_1 }, + { "CSISOLATIN1", RTL_TEXTENCODING_ISO_8859_1 }, + { "ISO-8859-2", RTL_TEXTENCODING_ISO_8859_2 }, + { "ISO_8859-2:1987", RTL_TEXTENCODING_ISO_8859_2 }, + { "ISO-IR-101", RTL_TEXTENCODING_ISO_8859_2 }, + { "ISO_8859-2", RTL_TEXTENCODING_ISO_8859_2 }, + { "LATIN2", RTL_TEXTENCODING_ISO_8859_2 }, + { "L2", RTL_TEXTENCODING_ISO_8859_2 }, + { "CSISOLATIN2", RTL_TEXTENCODING_ISO_8859_2 }, + { "ISO-8859-3", RTL_TEXTENCODING_ISO_8859_3 }, + { "ISO_8859-3:1988", RTL_TEXTENCODING_ISO_8859_3 }, + { "ISO-IR-109", RTL_TEXTENCODING_ISO_8859_3 }, + { "ISO_8859-3", RTL_TEXTENCODING_ISO_8859_3 }, + { "LATIN3", RTL_TEXTENCODING_ISO_8859_3 }, + { "L3", RTL_TEXTENCODING_ISO_8859_3 }, + { "CSISOLATIN3", RTL_TEXTENCODING_ISO_8859_3 }, + { "ISO-8859-4", RTL_TEXTENCODING_ISO_8859_4 }, + { "ISO_8859-4:1988", RTL_TEXTENCODING_ISO_8859_4 }, + { "ISO-IR-110", RTL_TEXTENCODING_ISO_8859_4 }, + { "ISO_8859-4", RTL_TEXTENCODING_ISO_8859_4 }, + { "LATIN4", RTL_TEXTENCODING_ISO_8859_4 }, + { "L4", RTL_TEXTENCODING_ISO_8859_4 }, + { "CSISOLATIN4", RTL_TEXTENCODING_ISO_8859_4 }, + { "ISO-8859-5", RTL_TEXTENCODING_ISO_8859_5 }, + { "ISO_8859-5:1988", RTL_TEXTENCODING_ISO_8859_5 }, + { "ISO-IR-144", RTL_TEXTENCODING_ISO_8859_5 }, + { "ISO_8859-5", RTL_TEXTENCODING_ISO_8859_5 }, + { "CYRILLIC", RTL_TEXTENCODING_ISO_8859_5 }, + { "CSISOLATINCYRILLIC", RTL_TEXTENCODING_ISO_8859_5 }, + { "ISO-8859-6", RTL_TEXTENCODING_ISO_8859_6 }, + { "ISO_8859-6:1987", RTL_TEXTENCODING_ISO_8859_6 }, + { "ISO-IR-127", RTL_TEXTENCODING_ISO_8859_6 }, + { "ISO_8859-6", RTL_TEXTENCODING_ISO_8859_6 }, + { "ECMA-114", RTL_TEXTENCODING_ISO_8859_6 }, + { "ASMO-708", RTL_TEXTENCODING_ISO_8859_6 }, + { "ARABIC", RTL_TEXTENCODING_ISO_8859_6 }, + { "CSISOLATINARABIC", RTL_TEXTENCODING_ISO_8859_6 }, + { "ISO-8859-7", RTL_TEXTENCODING_ISO_8859_7 }, + { "ISO_8859-7:1987", RTL_TEXTENCODING_ISO_8859_7 }, + { "ISO-IR-126", RTL_TEXTENCODING_ISO_8859_7 }, + { "ISO_8859-7", RTL_TEXTENCODING_ISO_8859_7 }, + { "ELOT_928", RTL_TEXTENCODING_ISO_8859_7 }, + { "ECMA-118", RTL_TEXTENCODING_ISO_8859_7 }, + { "GREEK", RTL_TEXTENCODING_ISO_8859_7 }, + { "GREEK8", RTL_TEXTENCODING_ISO_8859_7 }, + { "CSISOLATINGREEK", RTL_TEXTENCODING_ISO_8859_7 }, + { "ISO-8859-8", RTL_TEXTENCODING_ISO_8859_8 }, + { "ISO_8859-8:1988", RTL_TEXTENCODING_ISO_8859_8 }, + { "ISO-IR-138", RTL_TEXTENCODING_ISO_8859_8 }, + { "ISO_8859-8", RTL_TEXTENCODING_ISO_8859_8 }, + { "HEBREW", RTL_TEXTENCODING_ISO_8859_8 }, + { "CSISOLATINHEBREW", RTL_TEXTENCODING_ISO_8859_8 }, + { "ISO-8859-9", RTL_TEXTENCODING_ISO_8859_9 }, + { "ISO_8859-9:1989", RTL_TEXTENCODING_ISO_8859_9 }, + { "ISO-IR-148", RTL_TEXTENCODING_ISO_8859_9 }, + { "ISO_8859-9", RTL_TEXTENCODING_ISO_8859_9 }, + { "LATIN5", RTL_TEXTENCODING_ISO_8859_9 }, + { "L5", RTL_TEXTENCODING_ISO_8859_9 }, + { "CSISOLATIN5", RTL_TEXTENCODING_ISO_8859_9 }, + { "ISO-8859-14", RTL_TEXTENCODING_ISO_8859_14 }, // RFC 2047 + { "ISO_8859-15", RTL_TEXTENCODING_ISO_8859_15 }, + { "ISO-8859-15", RTL_TEXTENCODING_ISO_8859_15 }, // RFC 2047 + { "MACINTOSH", RTL_TEXTENCODING_APPLE_ROMAN }, + { "MAC", RTL_TEXTENCODING_APPLE_ROMAN }, + { "CSMACINTOSH", RTL_TEXTENCODING_APPLE_ROMAN }, + { "IBM437", RTL_TEXTENCODING_IBM_437 }, + { "CP437", RTL_TEXTENCODING_IBM_437 }, + { "437", RTL_TEXTENCODING_IBM_437 }, + { "CSPC8CODEPAGE437", RTL_TEXTENCODING_IBM_437 }, + { "IBM850", RTL_TEXTENCODING_IBM_850 }, + { "CP850", RTL_TEXTENCODING_IBM_850 }, + { "850", RTL_TEXTENCODING_IBM_850 }, + { "CSPC850MULTILINGUAL", RTL_TEXTENCODING_IBM_850 }, + { "IBM860", RTL_TEXTENCODING_IBM_860 }, + { "CP860", RTL_TEXTENCODING_IBM_860 }, + { "860", RTL_TEXTENCODING_IBM_860 }, + { "CSIBM860", RTL_TEXTENCODING_IBM_860 }, + { "IBM861", RTL_TEXTENCODING_IBM_861 }, + { "CP861", RTL_TEXTENCODING_IBM_861 }, + { "861", RTL_TEXTENCODING_IBM_861 }, + { "CP-IS", RTL_TEXTENCODING_IBM_861 }, + { "CSIBM861", RTL_TEXTENCODING_IBM_861 }, + { "IBM863", RTL_TEXTENCODING_IBM_863 }, + { "CP863", RTL_TEXTENCODING_IBM_863 }, + { "863", RTL_TEXTENCODING_IBM_863 }, + { "CSIBM863", RTL_TEXTENCODING_IBM_863 }, + { "IBM865", RTL_TEXTENCODING_IBM_865 }, + { "CP865", RTL_TEXTENCODING_IBM_865 }, + { "865", RTL_TEXTENCODING_IBM_865 }, + { "CSIBM865", RTL_TEXTENCODING_IBM_865 }, + { "IBM775", RTL_TEXTENCODING_IBM_775 }, + { "CP775", RTL_TEXTENCODING_IBM_775 }, + { "CSPC775BALTIC", RTL_TEXTENCODING_IBM_775 }, + { "IBM852", RTL_TEXTENCODING_IBM_852 }, + { "CP852", RTL_TEXTENCODING_IBM_852 }, + { "852", RTL_TEXTENCODING_IBM_852 }, + { "CSPCP852", RTL_TEXTENCODING_IBM_852 }, + { "IBM855", RTL_TEXTENCODING_IBM_855 }, + { "CP855", RTL_TEXTENCODING_IBM_855 }, + { "855", RTL_TEXTENCODING_IBM_855 }, + { "CSIBM855", RTL_TEXTENCODING_IBM_855 }, + { "IBM857", RTL_TEXTENCODING_IBM_857 }, + { "CP857", RTL_TEXTENCODING_IBM_857 }, + { "857", RTL_TEXTENCODING_IBM_857 }, + { "CSIBM857", RTL_TEXTENCODING_IBM_857 }, + { "IBM862", RTL_TEXTENCODING_IBM_862 }, + { "CP862", RTL_TEXTENCODING_IBM_862 }, + { "862", RTL_TEXTENCODING_IBM_862 }, + { "CSPC862LATINHEBREW", RTL_TEXTENCODING_IBM_862 }, + { "IBM864", RTL_TEXTENCODING_IBM_864 }, + { "CP864", RTL_TEXTENCODING_IBM_864 }, + { "CSIBM864", RTL_TEXTENCODING_IBM_864 }, + { "IBM866", RTL_TEXTENCODING_IBM_866 }, + { "CP866", RTL_TEXTENCODING_IBM_866 }, + { "866", RTL_TEXTENCODING_IBM_866 }, + { "CSIBM866", RTL_TEXTENCODING_IBM_866 }, + { "IBM869", RTL_TEXTENCODING_IBM_869 }, + { "CP869", RTL_TEXTENCODING_IBM_869 }, + { "869", RTL_TEXTENCODING_IBM_869 }, + { "CP-GR", RTL_TEXTENCODING_IBM_869 }, + { "CSIBM869", RTL_TEXTENCODING_IBM_869 }, + { "WINDOWS-1250", RTL_TEXTENCODING_MS_1250 }, + { "WINDOWS-1251", RTL_TEXTENCODING_MS_1251 }, + { "WINDOWS-1253", RTL_TEXTENCODING_MS_1253 }, + { "WINDOWS-1254", RTL_TEXTENCODING_MS_1254 }, + { "WINDOWS-1255", RTL_TEXTENCODING_MS_1255 }, + { "WINDOWS-1256", RTL_TEXTENCODING_MS_1256 }, + { "WINDOWS-1257", RTL_TEXTENCODING_MS_1257 }, + { "WINDOWS-1258", RTL_TEXTENCODING_MS_1258 }, + { "SHIFT_JIS", RTL_TEXTENCODING_SHIFT_JIS }, + { "MS_KANJI", RTL_TEXTENCODING_SHIFT_JIS }, + { "CSSHIFTJIS", RTL_TEXTENCODING_SHIFT_JIS }, + { "GB2312", RTL_TEXTENCODING_GB_2312 }, + { "CSGB2312", RTL_TEXTENCODING_GB_2312 }, + { "BIG5", RTL_TEXTENCODING_BIG5 }, + { "CSBIG5", RTL_TEXTENCODING_BIG5 }, + { "EUC-JP", RTL_TEXTENCODING_EUC_JP }, + { "EXTENDED_UNIX_CODE_PACKED_FORMAT_FOR_JAPANESE", + RTL_TEXTENCODING_EUC_JP }, + { "CSEUCPKDFMTJAPANESE", RTL_TEXTENCODING_EUC_JP }, + { "ISO-2022-JP", RTL_TEXTENCODING_ISO_2022_JP }, + { "CSISO2022JP", RTL_TEXTENCODING_ISO_2022_JP }, + { "ISO-2022-CN", RTL_TEXTENCODING_ISO_2022_CN }, + { "KOI8-R", RTL_TEXTENCODING_KOI8_R }, + { "CSKOI8R", RTL_TEXTENCODING_KOI8_R }, + { "UTF-7", RTL_TEXTENCODING_UTF7 }, + { "UTF-8", RTL_TEXTENCODING_UTF8 }, + { "ISO-8859-10", RTL_TEXTENCODING_ISO_8859_10 }, // RFC 2047 + { "ISO-8859-13", RTL_TEXTENCODING_ISO_8859_13 }, // RFC 2047 + { "EUC-KR", RTL_TEXTENCODING_EUC_KR }, + { "CSEUCKR", RTL_TEXTENCODING_EUC_KR }, + { "ISO-2022-KR", RTL_TEXTENCODING_ISO_2022_KR }, + { "CSISO2022KR", RTL_TEXTENCODING_ISO_2022_KR }, + { "ISO-10646-UCS-4", RTL_TEXTENCODING_UCS4 }, + { "CSUCS4", RTL_TEXTENCODING_UCS4 }, + { "ISO-10646-UCS-2", RTL_TEXTENCODING_UCS2 }, + { "CSUNICODE", RTL_TEXTENCODING_UCS2 } }; + +//============================================================================ +template< typename T > +inline rtl_TextEncoding getCharsetEncoding_Impl(T const * pBegin, + T const * pEnd) +{ + for (sal_Size i = 0; i < sizeof aEncodingMap / sizeof (EncodingEntry); + ++i) + if (INetMIME::equalIgnoreCase(pBegin, pEnd, aEncodingMap[i].m_aName)) + return aEncodingMap[i].m_eEncoding; + return RTL_TEXTENCODING_DONTKNOW; +} + +} + +//============================================================================ +// static +rtl_TextEncoding INetMIME::getCharsetEncoding(sal_Char const * pBegin, + sal_Char const * pEnd) +{ + return getCharsetEncoding_Impl(pBegin, pEnd); +} + +//============================================================================ +// static +rtl_TextEncoding INetMIME::getCharsetEncoding(sal_Unicode const * pBegin, + sal_Unicode const * pEnd) +{ + return getCharsetEncoding_Impl(pBegin, pEnd); +} + +//============================================================================ +// static +INetMIMECharsetList_Impl * +INetMIME::createPreferredCharsetList(rtl_TextEncoding eEncoding) +{ + static const sal_uInt32 aUSASCIIRanges[] = { 0, 0x7F, sal_uInt32(-1) }; + + static const sal_uInt32 aISO88591Ranges[] = { 0, 0xFF, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-1.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88592Ranges[] + = { 0, 0xA0, 0xA4, 0xA4, 0xA7, 0xA8, 0xAD, 0xAD, 0xB0, 0xB0, + 0xB4, 0xB4, 0xB8, 0xB8, 0xC1, 0xC2, 0xC4, 0xC4, 0xC7, 0xC7, + 0xC9, 0xC9, 0xCB, 0xCB, 0xCD, 0xCE, 0xD3, 0xD4, 0xD6, 0xD7, + 0xDA, 0xDA, 0xDC, 0xDD, 0xDF, 0xDF, 0xE1, 0xE2, 0xE4, 0xE4, + 0xE7, 0xE7, 0xE9, 0xE9, 0xEB, 0xEB, 0xED, 0xEE, 0xF3, 0xF4, + 0xF6, 0xF7, 0xFA, 0xFA, 0xFC, 0xFD, 0x102, 0x107, 0x10C, 0x111, + 0x118, 0x11B, 0x139, 0x13A, 0x13D, 0x13E, 0x141, 0x144, + 0x147, 0x148, 0x150, 0x151, 0x154, 0x155, 0x158, 0x15B, + 0x15E, 0x165, 0x16E, 0x171, 0x179, 0x17E, 0x2C7, 0x2C7, + 0x2D8, 0x2D9, 0x2DB, 0x2DB, 0x2DD, 0x2DD, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-2.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88593Ranges[] + = { 0, 0xA0, 0xA3, 0xA4, 0xA7, 0xA8, 0xAD, 0xAD, 0xB0, 0xB0, + 0xB2, 0xB5, 0xB7, 0xB8, 0xBD, 0xBD, 0xC0, 0xC2, 0xC4, 0xC4, + 0xC7, 0xCF, 0xD1, 0xD4, 0xD6, 0xD7, 0xD9, 0xDC, 0xDF, 0xE2, + 0xE4, 0xE4, 0xE7, 0xEF, 0xF1, 0xF4, 0xF6, 0xF7, 0xF9, 0xFC, + 0x108, 0x10B, 0x11C, 0x121, 0x124, 0x127, 0x130, 0x131, + 0x134, 0x135, 0x15C, 0x15F, 0x16C, 0x16D, 0x17B, 0x17C, + 0x2D8, 0x2D9, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-3.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88594Ranges[] + = { 0, 0xA0, 0xA4, 0xA4, 0xA7, 0xA8, 0xAD, 0xAD, 0xAF, 0xB0, + 0xB4, 0xB4, 0xB8, 0xB8, 0xC1, 0xC6, 0xC9, 0xC9, 0xCB, 0xCB, + 0xCD, 0xCE, 0xD4, 0xD8, 0xDA, 0xDC, 0xDF, 0xDF, 0xE1, 0xE6, + 0xE9, 0xE9, 0xEB, 0xEB, 0xED, 0xEE, 0xF4, 0xF8, 0xFA, 0xFC, + 0x100, 0x101, 0x104, 0x105, 0x10C, 0x10D, 0x110, 0x113, + 0x116, 0x119, 0x122, 0x123, 0x128, 0x12B, 0x12E, 0x12F, + 0x136, 0x138, 0x13B, 0x13C, 0x145, 0x146, 0x14A, 0x14D, + 0x156, 0x157, 0x160, 0x161, 0x166, 0x16B, 0x172, 0x173, + 0x17D, 0x17E, 0x2C7, 0x2C7, 0x2D9, 0x2D9, 0x2DB, 0x2DB, + sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-4.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88595Ranges[] + = { 0, 0xA0, 0xA7, 0xA7, 0xAD, 0xAD, 0x401, 0x40C, 0x40E, 0x44F, + 0x451, 0x45C, 0x45E, 0x45F, 0x2116, 0x2116, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-5.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88596Ranges[] + = { 0, 0xA0, 0xA4, 0xA4, 0xAD, 0xAD, 0x60C, 0x60C, 0x61B, 0x61B, + 0x61F, 0x61F, 0x621, 0x63A, 0x640, 0x652, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-6.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88597Ranges[] + = { 0, 0xA0, 0xA3, 0xA3, 0xA6, 0xA9, 0xAB, 0xAD, 0xB0, 0xB3, + 0xB7, 0xB7, 0xBB, 0xBB, 0xBD, 0xBD, 0x384, 0x386, 0x388, 0x38A, + 0x38C, 0x38C, 0x38E, 0x3A1, 0x3A3, 0x3CE, 0x2015, 0x2015, + 0x2018, 0x2019, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-7.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO88598Ranges[] + = { 0, 0xA0, 0xA2, 0xA9, 0xAB, 0xB9, 0xBB, 0xBE, 0xD7, 0xD7, + 0xF7, 0xF7, 0x5D0, 0x5EA, 0x200E, 0x200F, 0x2017, 0x2017, + sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-8.TXT> version + // 1.1 of 2000-Jan-03 + + static const sal_uInt32 aISO88599Ranges[] + = { 0, 0xCF, 0xD1, 0xDC, 0xDF, 0xEF, 0xF1, 0xFC, 0xFF, 0xFF, + 0x11E, 0x11F, 0x130, 0x131, 0x15E, 0x15F, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-9.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO885910Ranges[] + = { 0, 0xA0, 0xA7, 0xA7, 0xAD, 0xAD, 0xB0, 0xB0, 0xB7, 0xB7, + 0xC1, 0xC6, 0xC9, 0xC9, 0xCB, 0xCB, 0xCD, 0xD0, 0xD3, 0xD6, + 0xD8, 0xD8, 0xDA, 0xDF, 0xE1, 0xE6, 0xE9, 0xE9, 0xEB, 0xEB, + 0xED, 0xF0, 0xF3, 0xF6, 0xF8, 0xF8, 0xFA, 0xFE, 0x100, 0x101, + 0x104, 0x105, 0x10C, 0x10D, 0x110, 0x113, 0x116, 0x119, + 0x122, 0x123, 0x128, 0x12B, 0x12E, 0x12F, 0x136, 0x138, + 0x13B, 0x13C, 0x145, 0x146, 0x14A, 0x14D, 0x160, 0x161, + 0x166, 0x16B, 0x172, 0x173, 0x17D, 0x17E, 0x2015, 0x2015, + sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-10.TXT> version + // 1.1 of 1999 October 11 + + static const sal_uInt32 aISO885913Ranges[] + = { 0, 0xA0, 0xA2, 0xA4, 0xA6, 0xA7, 0xA9, 0xA9, 0xAB, 0xAE, + 0xB0, 0xB3, 0xB5, 0xB7, 0xB9, 0xB9, 0xBB, 0xBE, 0xC4, 0xC6, + 0xC9, 0xC9, 0xD3, 0xD3, 0xD5, 0xD8, 0xDC, 0xDC, 0xDF, 0xDF, + 0xE4, 0xE6, 0xE9, 0xE9, 0xF3, 0xF3, 0xF5, 0xF8, 0xFC, 0xFC, + 0x100, 0x101, 0x104, 0x107, 0x10C, 0x10D, 0x112, 0x113, + 0x116, 0x119, 0x122, 0x123, 0x12A, 0x12B, 0x12E, 0x12F, + 0x136, 0x137, 0x13B, 0x13C, 0x141, 0x146, 0x14C, 0x14D, + 0x156, 0x157, 0x15A, 0x15B, 0x160, 0x161, 0x16A, 0x16B, + 0x172, 0x173, 0x179, 0x17E, 0x2019, 0x2019, 0x201C, 0x201E, + sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-13.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO885914Ranges[] + = { 0, 0xA0, 0xA3, 0xA3, 0xA7, 0xA7, 0xA9, 0xA9, 0xAD, 0xAE, + 0xB6, 0xB6, 0xC0, 0xCF, 0xD1, 0xD6, 0xD8, 0xDD, 0xDF, 0xEF, + 0xF1, 0xF6, 0xF8, 0xFD, 0xFF, 0xFF, 0x10A, 0x10B, 0x120, 0x121, + 0x174, 0x178, 0x1E02, 0x1E03, 0x1E0A, 0x1E0B, 0x1E1E, 0x1E1F, + 0x1E40, 0x1E41, 0x1E56, 0x1E57, 0x1E60, 0x1E61, 0x1E6A, 0x1E6B, + 0x1E80, 0x1E85, 0x1EF2, 0x1EF3, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-14.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aISO885915Ranges[] + = { 0, 0xA3, 0xA5, 0xA5, 0xA7, 0xA7, 0xA9, 0xB3, 0xB5, 0xB7, + 0xB9, 0xBB, 0xBF, 0xFF, 0x152, 0x153, 0x160, 0x161, 0x178, 0x178, + 0x17D, 0x17E, 0x20AC, 0x20AC, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/8859-15.TXT> version + // 1.0 of 1999 July 27 + + static const sal_uInt32 aKOI8RRanges[] + = { 0, 0x7F, 0xA0, 0xA0, 0xA9, 0xA9, 0xB0, 0xB0, 0xB2, 0xB2, + 0xB7, 0xB7, 0xF7, 0xF7, 0x401, 0x401, 0x410, 0x44F, 0x451, 0x451, + 0x2219, 0x221A, 0x2248, 0x2248, 0x2264, 0x2265, 0x2320, 0x2321, + 0x2500, 0x2500, 0x2502, 0x2502, 0x250C, 0x250C, 0x2510, 0x2510, + 0x2514, 0x2514, 0x2518, 0x2518, 0x251C, 0x251C, 0x2524, 0x2524, + 0x252C, 0x252C, 0x2534, 0x2534, 0x253C, 0x253C, 0x2550, 0x256C, + 0x2580, 0x2580, 0x2584, 0x2584, 0x2588, 0x2588, 0x258C, 0x258C, + 0x2590, 0x2593, 0x25A0, 0x25A0, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MISC/KOI8-R.TXT> + // version 1.0 of 18 August 1999 + + static const sal_uInt32 aWindows1252Ranges[] + = { 0, 0x7F, 0xA0, 0xFF, 0x152, 0x153, 0x160, 0x161, 0x178, 0x178, + 0x17D, 0x17E, 0x192, 0x192, 0x2C6, 0x2C6, 0x2DC, 0x2DC, + 0x2013, 0x2014, 0x2018, 0x201A, 0x201C, 0x201E, 0x2020, 0x2022, + 0x2026, 0x2026, 0x2030, 0x2030, 0x2039, 0x203A, 0x20AC, 0x20AC, + 0x2122, 0x2122, sal_uInt32(-1) }; + // <ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/ + // CP1252.TXT> version 2.01 of 04/15/98 + + INetMIMECharsetList_Impl * pList = new INetMIMECharsetList_Impl; + switch (eEncoding) + { + case RTL_TEXTENCODING_MS_1252: +#if defined WNT + pList->prepend(Charset(RTL_TEXTENCODING_MS_1252, + aWindows1252Ranges)); +#endif // WNT + case RTL_TEXTENCODING_ISO_8859_1: + case RTL_TEXTENCODING_UTF7: + case RTL_TEXTENCODING_UTF8: + break; + + case RTL_TEXTENCODING_ISO_8859_2: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_2, + aISO88592Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_3: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_3, + aISO88593Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_4: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_4, + aISO88594Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_5: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_5, + aISO88595Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_6: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_6, + aISO88596Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_7: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_7, + aISO88597Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_8: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_8, + aISO88598Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_9: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_9, + aISO88599Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_10: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_10, + aISO885910Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_13: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_13, + aISO885913Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_14: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_14, + aISO885914Ranges)); + break; + + case RTL_TEXTENCODING_ISO_8859_15: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_15, + aISO885915Ranges)); + break; + + case RTL_TEXTENCODING_MS_1250: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_2, + aISO88592Ranges)); + break; + + case RTL_TEXTENCODING_MS_1251: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_5, + aISO88595Ranges)); + break; + + case RTL_TEXTENCODING_MS_1253: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_7, + aISO88597Ranges)); + break; + + case RTL_TEXTENCODING_MS_1254: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_9, + aISO88599Ranges)); + break; + + case RTL_TEXTENCODING_MS_1255: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_8, + aISO88598Ranges)); + break; + + case RTL_TEXTENCODING_MS_1256: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_6, + aISO88596Ranges)); + break; + + case RTL_TEXTENCODING_MS_1257: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_4, + aISO88594Ranges)); + break; + + case RTL_TEXTENCODING_KOI8_R: + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_5, + aISO88595Ranges)); + pList->prepend(Charset(RTL_TEXTENCODING_KOI8_R, aKOI8RRanges)); + break; + + default: //@@@ more cases are missing! + DBG_ERROR("INetMIME::createPreferredCharsetList():" + " Unsupported encoding"); + break; + } + pList->prepend(Charset(RTL_TEXTENCODING_ISO_8859_1, aISO88591Ranges)); + pList->prepend(Charset(RTL_TEXTENCODING_ASCII_US, aUSASCIIRanges)); + return pList; +} + +//============================================================================ +// static +sal_Unicode * INetMIME::convertToUnicode(const sal_Char * pBegin, + const sal_Char * pEnd, + rtl_TextEncoding eEncoding, + sal_Size & rSize) +{ + if (eEncoding == RTL_TEXTENCODING_DONTKNOW) + return 0; + rtl_TextToUnicodeConverter hConverter + = rtl_createTextToUnicodeConverter(eEncoding); + rtl_TextToUnicodeContext hContext + = rtl_createTextToUnicodeContext(hConverter); + sal_Unicode * pBuffer; + sal_uInt32 nInfo; + for (sal_Size nBufferSize = pEnd - pBegin;; + nBufferSize += nBufferSize / 3 + 1) + { + pBuffer = new sal_Unicode[nBufferSize]; + sal_Size nSrcCvtBytes; + rSize = rtl_convertTextToUnicode( + hConverter, hContext, pBegin, pEnd - pBegin, pBuffer, + nBufferSize, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR + | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR + | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR, + &nInfo, &nSrcCvtBytes); + if (nInfo != RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL) + break; + delete[] pBuffer; + rtl_resetTextToUnicodeContext(hConverter, hContext); + } + rtl_destroyTextToUnicodeContext(hConverter, hContext); + rtl_destroyTextToUnicodeConverter(hConverter); + if (nInfo != 0) + { + delete[] pBuffer; + pBuffer = 0; + } + return pBuffer; +} + +//============================================================================ +// static +sal_Char * INetMIME::convertFromUnicode(const sal_Unicode * pBegin, + const sal_Unicode * pEnd, + rtl_TextEncoding eEncoding, + sal_Size & rSize) +{ + if (eEncoding == RTL_TEXTENCODING_DONTKNOW) + return 0; + rtl_UnicodeToTextConverter hConverter + = rtl_createUnicodeToTextConverter(eEncoding); + rtl_UnicodeToTextContext hContext + = rtl_createUnicodeToTextContext(hConverter); + sal_Char * pBuffer; + sal_uInt32 nInfo; + for (sal_Size nBufferSize = pEnd - pBegin;; + nBufferSize += nBufferSize / 3 + 1) + { + pBuffer = new sal_Char[nBufferSize]; + sal_Size nSrcCvtBytes; + rSize = rtl_convertUnicodeToText( + hConverter, hContext, pBegin, pEnd - pBegin, pBuffer, + nBufferSize, + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR + | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR + | RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE + | RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR, + &nInfo, &nSrcCvtBytes); + if (nInfo != RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL) + break; + delete[] pBuffer; + rtl_resetUnicodeToTextContext(hConverter, hContext); + } + rtl_destroyUnicodeToTextContext(hConverter, hContext); + rtl_destroyUnicodeToTextConverter(hConverter); + if (nInfo != 0) + { + delete[] pBuffer; + pBuffer = 0; + } + return pBuffer; +} + +//============================================================================ +// static +void INetMIME::writeUTF8(INetMIMEOutputSink & rSink, sal_uInt32 nChar) +{ + // See RFC 2279 for a discussion of UTF-8. + DBG_ASSERT(nChar < 0x80000000, "INetMIME::writeUTF8(): Bad char"); + + if (nChar < 0x80) + rSink << sal_Char(nChar); + else if (nChar < 0x800) + rSink << sal_Char(nChar >> 6 | 0xC0) + << sal_Char(nChar & 0x3F | 0x80); + else if (nChar < 0x10000) + rSink << sal_Char(nChar >> 12 | 0xE0) + << sal_Char(nChar >> 6 & 0x3F | 0x80) + << sal_Char(nChar & 0x3F | 0x80); + else if (nChar < 0x200000) + rSink << sal_Char(nChar >> 18 | 0xF0) + << sal_Char(nChar >> 12 & 0x3F | 0x80) + << sal_Char(nChar >> 6 & 0x3F | 0x80) + << sal_Char(nChar & 0x3F | 0x80); + else if (nChar < 0x4000000) + rSink << sal_Char(nChar >> 24 | 0xF8) + << sal_Char(nChar >> 18 & 0x3F | 0x80) + << sal_Char(nChar >> 12 & 0x3F | 0x80) + << sal_Char(nChar >> 6 & 0x3F | 0x80) + << sal_Char(nChar & 0x3F | 0x80); + else + rSink << sal_Char(nChar >> 30 | 0xFC) + << sal_Char(nChar >> 24 & 0x3F | 0x80) + << sal_Char(nChar >> 18 & 0x3F | 0x80) + << sal_Char(nChar >> 12 & 0x3F | 0x80) + << sal_Char(nChar >> 6 & 0x3F | 0x80) + << sal_Char(nChar & 0x3F | 0x80); +} + +//============================================================================ +// static +void INetMIME::writeUnsigned(INetMIMEOutputSink & rSink, sal_uInt32 nValue, + int nMinDigits) +{ + sal_Char aBuffer[10]; + // max unsigned 32 bit value (4294967295) has 10 places + sal_Char * p = aBuffer; + for (; nValue > 0; nValue /= 10) + *p++ = sal_Char(getDigit(nValue % 10)); + nMinDigits -= p - aBuffer; + while (nMinDigits-- > 0) + rSink << '0'; + while (p != aBuffer) + rSink << *--p; +} + +//============================================================================ +// static +void INetMIME::writeDateTime(INetMIMEOutputSink & rSink, + const DateTime & rUTC) +{ + static const sal_Char aDay[7][3] + = { { 'M', 'o', 'n' }, + { 'T', 'u', 'e' }, + { 'W', 'e', 'd' }, + { 'T', 'h', 'u' }, + { 'F', 'r', 'i' }, + { 'S', 'a', 't' }, + { 'S', 'u', 'n' } }; + const sal_Char * pTheDay = aDay[rUTC.GetDayOfWeek()]; + rSink.write(pTheDay, pTheDay + 3); + rSink << ", "; + writeUnsigned(rSink, rUTC.GetDay()); + rSink << ' '; + static const sal_Char aMonth[12][3] + = { { 'J', 'a', 'n' }, + { 'F', 'e', 'b' }, + { 'M', 'a', 'r' }, + { 'A', 'p', 'r' }, + { 'M', 'a', 'y' }, + { 'J', 'u', 'n' }, + { 'J', 'u', 'l' }, + { 'A', 'u', 'g' }, + { 'S', 'e', 'p' }, + { 'O', 'c', 't' }, + { 'N', 'o', 'v' }, + { 'D', 'e', 'c' } }; + const sal_Char * pTheMonth = aMonth[rUTC.GetMonth() - 1]; + rSink.write(pTheMonth, pTheMonth + 3); + rSink << ' '; + writeUnsigned(rSink, rUTC.GetYear()); + rSink << ' '; + writeUnsigned(rSink, rUTC.GetHour(), 2); + rSink << ':'; + writeUnsigned(rSink, rUTC.GetMin(), 2); + rSink << ':'; + writeUnsigned(rSink, rUTC.GetSec(), 2); + rSink << " +0000"; +} + +//============================================================================ +// static +void INetMIME::writeHeaderFieldBody(INetMIMEOutputSink & rSink, + HeaderFieldType eType, + const ByteString & rBody, + rtl_TextEncoding ePreferredEncoding, + bool bInitialSpace) +{ + writeHeaderFieldBody(rSink, eType, + UniString(rBody, RTL_TEXTENCODING_UTF8), + ePreferredEncoding); +} + +//============================================================================ +// static +void INetMIME::writeHeaderFieldBody(INetMIMEOutputSink & rSink, + HeaderFieldType eType, + const UniString & rBody, + rtl_TextEncoding ePreferredEncoding, + bool bInitialSpace) +{ + if (eType == HEADER_FIELD_TEXT) + { + INetMIMEEncodedWordOutputSink + aOutput(rSink, INetMIMEEncodedWordOutputSink::CONTEXT_TEXT, + bInitialSpace ? + INetMIMEEncodedWordOutputSink::SPACE_ALWAYS : + INetMIMEEncodedWordOutputSink::SPACE_NO, + ePreferredEncoding); + aOutput.write(rBody.GetBuffer(), rBody.GetBuffer() + rBody.Len()); + aOutput.flush(); + } + else + { + enum Brackets { BRACKETS_OUTSIDE, BRACKETS_OPENING, BRACKETS_INSIDE }; + Brackets eBrackets = BRACKETS_OUTSIDE; + + const sal_Unicode * pBodyPtr = rBody.GetBuffer(); + const sal_Unicode * pBodyEnd = pBodyPtr + rBody.Len(); + while (pBodyPtr != pBodyEnd) + switch (*pBodyPtr) + { + case '\t': + case ' ': + // A WSP adds to accumulated space: + bInitialSpace = true; + ++pBodyPtr; + break; + + case '(': + { + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + eBrackets = BRACKETS_INSIDE; + } + + // Write the comment, introducing encoded-words where + // necessary: + int nLevel = 0; + INetMIMEEncodedWordOutputSink + aOutput( + rSink, + INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT, + INetMIMEEncodedWordOutputSink::SPACE_NO, + ePreferredEncoding); + while (pBodyPtr != pBodyEnd) + switch (*pBodyPtr) + { + case '(': + aOutput.flush(); + if (rSink.getColumn() + + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '('; + bInitialSpace = false; + ++nLevel; + ++pBodyPtr; + break; + + case ')': + aOutput.flush(); + if (rSink.getColumn() + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + rSink << ')'; + ++pBodyPtr; + if (--nLevel == 0) + goto comment_done; + break; + + case '\\': + if (++pBodyPtr == pBodyEnd) + break; + default: + aOutput << *pBodyPtr++; + break; + } + comment_done: + break; + } + + case '<': + // Write an already pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + } + + // Remember this '<' as pending, and open a bracketed + // block: + eBrackets = BRACKETS_OPENING; + ++pBodyPtr; + break; + + case '>': + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + } + + // Write this '>', and close any bracketed block: + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '>'; + bInitialSpace = false; + eBrackets = BRACKETS_OUTSIDE; + ++pBodyPtr; + break; + + case ',': + case ':': + case ';': + case '\\': + case ']': + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + eBrackets = BRACKETS_INSIDE; + } + + // Write this specials: + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << sal_Char(*pBodyPtr++); + bInitialSpace = false; + break; + + case '\x0D': // CR + // A <CRLF WSP> adds to accumulated space, a <CR> not + // followed by <LF WSP> starts 'junk': + if (startsWithLineFolding(pBodyPtr, pBodyEnd)) + { + bInitialSpace = true; + pBodyPtr += 3; + break; + } + default: + { + // The next token is either one of <"." / "@" / atom / + // quoted-string / domain-literal>, or it's 'junk'; if it + // is not 'junk', it is either a 'phrase' (i.e., it may + // contain encoded-words) or a 'non-phrase' (i.e., it may + // not contain encoded-words): + enum Entity { ENTITY_JUNK, ENTITY_NON_PHRASE, + ENTITY_PHRASE }; + Entity eEntity; + switch (*pBodyPtr) + { + case '.': + case '@': + case '[': + // A token of <"." / "@" / domain-literal> always + // starts a 'non-phrase': + eEntity = ENTITY_NON_PHRASE; + break; + + default: + if (isUSASCII(*pBodyPtr) + && !isAtomChar(*pBodyPtr)) + { + eEntity = ENTITY_JUNK; + break; + } + case '"': + // A token of <atom / quoted-string> can either be + // a 'phrase' or a 'non-phrase': + switch (eType) + { + case HEADER_FIELD_STRUCTURED: + eEntity = ENTITY_NON_PHRASE; + break; + + case HEADER_FIELD_PHRASE: + eEntity = ENTITY_PHRASE; + break; + + case HEADER_FIELD_MESSAGE_ID: + // A 'phrase' if and only if outside any + // bracketed block: + eEntity + = eBrackets == BRACKETS_OUTSIDE ? + ENTITY_PHRASE : + ENTITY_NON_PHRASE; + break; + + case HEADER_FIELD_ADDRESS: + { + // A 'non-phrase' if and only if, after + // skipping this token and any following + // <linear-white-space> and <comment>s, + // there is no token left, or the next + // token is any of <"." / "@" / ">" / "," + // / ";">, or the next token is <":"> and + // is within a bracketed block: + const sal_Unicode * pLookAhead = pBodyPtr; + if (*pLookAhead == '"') + { + pLookAhead + = skipQuotedString(pLookAhead, + pBodyEnd); + if (pLookAhead == pBodyPtr) + pLookAhead = pBodyEnd; + } + else + while (pLookAhead != pBodyEnd + && (isAtomChar(*pLookAhead) + || !isUSASCII( + *pLookAhead))) + ++pLookAhead; + while (pLookAhead != pBodyEnd) + switch (*pLookAhead) + { + case '\t': + case ' ': + ++pLookAhead; + break; + + case '(': + { + const sal_Unicode * pPast + = skipComment(pLookAhead, + pBodyEnd); + pLookAhead + = pPast == pLookAhead ? + pBodyEnd : pPast; + break; + } + + case ',': + case '.': + case ';': + case '>': + case '@': + eEntity = ENTITY_NON_PHRASE; + goto entity_determined; + + case ':': + eEntity + = eBrackets + == BRACKETS_OUTSIDE ? + ENTITY_PHRASE : + ENTITY_NON_PHRASE; + goto entity_determined; + + case '\x0D': // CR + if (startsWithLineFolding( + pLookAhead, pBodyEnd)) + { + pLookAhead += 3; + break; + } + default: + eEntity = ENTITY_PHRASE; + goto entity_determined; + } + eEntity = ENTITY_NON_PHRASE; + entity_determined: + break; + } + } + + // In a 'non-phrase', a non-US-ASCII character + // cannot be part of an <atom>, but instead the + // whole entity is 'junk' rather than 'non- + // phrase': + if (eEntity == ENTITY_NON_PHRASE + && !isUSASCII(*pBodyPtr)) + eEntity = ENTITY_JUNK; + break; + } + + switch (eEntity) + { + case ENTITY_JUNK: + { + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + eBrackets = BRACKETS_INSIDE; + } + + // Calculate the length of in- and output: + const sal_Unicode * pStart = pBodyPtr; + sal_uInt32 nLength = 0; + bool bModify = false; + bool bEnd = false; + while (pBodyPtr != pBodyEnd && !bEnd) + switch (*pBodyPtr) + { + case '\x0D': // CR + if (startsWithLineFolding(pBodyPtr, + pBodyEnd)) + bEnd = true; + else if (startsWithLineBreak( + pBodyPtr, pBodyEnd)) + { + nLength += 3; + bModify = true; + pBodyPtr += 2; + } + else + { + ++nLength; + ++pBodyPtr; + } + break; + + case '\t': + case ' ': + bEnd = true; + break; + + default: + if (isVisible(*pBodyPtr)) + bEnd = true; + else if (isUSASCII(*pBodyPtr)) + { + ++nLength; + ++pBodyPtr; + } + else + { + nLength += getUTF8OctetCount( + *pBodyPtr++); + bModify = true; + } + break; + } + + // Write the output: + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + + nLength + > rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + bInitialSpace = false; + if (bModify) + while (pStart != pBodyPtr) + if (startsWithLineBreak(pStart, pBodyPtr)) + { + rSink << "\x0D\\\x0A"; // CR, '\', LF + pStart += 2; + } + else + writeUTF8(rSink, *pStart++); + else + rSink.write(pStart, pBodyPtr); + break; + } + + case ENTITY_NON_PHRASE: + { + // Calculate the length of in- and output: + const sal_Unicode * pStart = pBodyPtr; + sal_uInt32 nLength = 0; + bool bBracketedBlock = false; + bool bSymbol = *pStart != '.' && *pStart != '@'; + bool bModify = false; + bool bEnd = false; + while (pBodyPtr != pBodyEnd && !bEnd) + switch (*pBodyPtr) + { + case '\t': + case ' ': + case '\x0D': // CR + { + const sal_Unicode * pLookAhead + = skipLinearWhiteSpace(pBodyPtr, + pBodyEnd); + if (pLookAhead < pBodyEnd + && (bSymbol ? + isAtomChar(*pLookAhead) + || *pLookAhead == '"' + || *pLookAhead == '[' : + *pLookAhead == '.' + || *pLookAhead == '@' + || *pLookAhead == '>' + && eType + >= HEADER_FIELD_MESSAGE_ID + && eBrackets + == BRACKETS_OPENING)) + { + bModify = true; + pBodyPtr = pLookAhead; + } + else + bEnd = true; + break; + } + + case '"': + if (bSymbol) + { + pBodyPtr + = scanQuotedBlock(pBodyPtr, + pBodyEnd, + '"', '"', + nLength, + bModify); + bSymbol = false; + } + else + bEnd = true; + break; + + case '[': + if (bSymbol) + { + pBodyPtr + = scanQuotedBlock(pBodyPtr, + pBodyEnd, + '[', ']', + nLength, + bModify); + bSymbol = false; + } + else + bEnd = true; + break; + + case '.': + case '@': + if (bSymbol) + bEnd = true; + else + { + ++nLength; + bSymbol = true; + ++pBodyPtr; + } + break; + + case '>': + if (eBrackets == BRACKETS_OPENING + && eType + >= HEADER_FIELD_MESSAGE_ID) + { + ++nLength; + bBracketedBlock = true; + ++pBodyPtr; + } + bEnd = true; + break; + + default: + if (isAtomChar(*pBodyPtr) && bSymbol) + { + while (pBodyPtr != pBodyEnd + && isAtomChar(*pBodyPtr)) + { + ++nLength; + ++pBodyPtr; + } + bSymbol = false; + } + else + { + if (!isUSASCII(*pBodyPtr)) + bModify = true; + bEnd = true; + } + break; + } + + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING + && !bBracketedBlock) + { + if (rSink.getColumn() + + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + eBrackets = BRACKETS_INSIDE; + } + + // Write the output: + if (rSink.getColumn() + (bInitialSpace ? 1 : 0) + + nLength + > rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + bInitialSpace = false; + if (bBracketedBlock) + { + rSink << '<'; + eBrackets = BRACKETS_OUTSIDE; + } + if (bModify) + { + enum Mode { MODE_PLAIN, MODE_QUOTED_STRING, + MODE_DOMAIN_LITERAL }; + Mode eMode = MODE_PLAIN; + while (pStart != pBodyPtr) + switch (*pStart) + { + case '\x0D': // CR + if (startsWithLineFolding( + pStart, pBodyPtr)) + { + if (eMode != MODE_PLAIN) + rSink << sal_Char( + pStart[2]); + pStart += 3; + } + else if (startsWithLineBreak( + pStart, pBodyPtr)) + { + rSink << "\x0D\\\x0A"; + // CR, '\', LF + pStart += 2; + } + else + { + rSink << '\x0D'; // CR + ++pStart; + } + break; + + case '\t': + case ' ': + if (eMode != MODE_PLAIN) + rSink << sal_Char(*pStart); + ++pStart; + break; + + case '"': + if (eMode == MODE_PLAIN) + eMode = MODE_QUOTED_STRING; + else if (eMode + == MODE_QUOTED_STRING) + eMode = MODE_PLAIN; + rSink << '"'; + ++pStart; + break; + + case '[': + if (eMode == MODE_PLAIN) + eMode = MODE_DOMAIN_LITERAL; + rSink << '['; + ++pStart; + break; + + case ']': + if (eMode == MODE_DOMAIN_LITERAL) + eMode = MODE_PLAIN; + rSink << ']'; + ++pStart; + break; + + case '\\': + rSink << '\\'; + if (++pStart < pBodyPtr) + writeUTF8(rSink, *pStart++); + break; + + default: + writeUTF8(rSink, *pStart++); + break; + } + } + else + rSink.write(pStart, pBodyPtr); + break; + } + + case ENTITY_PHRASE: + { + // Write a pending '<' if necessary: + if (eBrackets == BRACKETS_OPENING) + { + if (rSink.getColumn() + + (bInitialSpace ? 1 : 0) + >= rSink.getLineLengthLimit()) + rSink << INetMIMEOutputSink::endl << ' '; + else if (bInitialSpace) + rSink << ' '; + rSink << '<'; + bInitialSpace = false; + eBrackets = BRACKETS_INSIDE; + } + + // Calculate the length of in- and output: + const sal_Unicode * pStart = pBodyPtr; + bool bQuotedString = false; + bool bEnd = false; + while (pBodyPtr != pBodyEnd && !bEnd) + switch (*pBodyPtr) + { + case '\t': + case ' ': + case '\x0D': // CR + if (bQuotedString) + ++pBodyPtr; + else + { + const sal_Unicode * pLookAhead + = skipLinearWhiteSpace( + pBodyPtr, pBodyEnd); + if (pLookAhead != pBodyEnd + && (isAtomChar(*pLookAhead) + || !isUSASCII(*pLookAhead) + || *pLookAhead == '"')) + pBodyPtr = pLookAhead; + else + bEnd = true; + } + break; + + case '"': + bQuotedString = !bQuotedString; + ++pBodyPtr; + break; + + case '\\': + if (bQuotedString) + { + if (++pBodyPtr != pBodyEnd) + ++pBodyPtr; + } + else + bEnd = true; + break; + + default: + if (bQuotedString + || isAtomChar(*pBodyPtr) + || !isUSASCII(*pBodyPtr)) + ++pBodyPtr; + else + bEnd = true; + break; + } + + // Write the phrase, introducing encoded-words + // where necessary: + INetMIMEEncodedWordOutputSink + aOutput( + rSink, + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, + bInitialSpace ? + INetMIMEEncodedWordOutputSink::SPACE_ALWAYS : + INetMIMEEncodedWordOutputSink::SPACE_ENCODED, + ePreferredEncoding); + while (pStart != pBodyPtr) + switch (*pStart) + { + case '"': + ++pStart; + break; + + case '\\': + if (++pStart != pBodyPtr) + aOutput << *pStart++; + break; + + case '\x0D': // CR + pStart += 2; + aOutput << *pStart++; + break; + + default: + aOutput << *pStart++; + break; + } + bInitialSpace = aOutput.flush(); + break; + } + } + break; + } + } + } +} + +//============================================================================ +// static +bool INetMIME::translateUTF8Char(const sal_Char *& rBegin, + const sal_Char * pEnd, + rtl_TextEncoding eEncoding, + sal_uInt32 & rCharacter) +{ + if (rBegin == pEnd || *rBegin < 0x80 || *rBegin >= 0xFE) + return false; + + int nCount; + sal_uInt32 nMin; + sal_uInt32 nUCS4; + const sal_Char * p = rBegin; + if (*p < 0xE0) + { + nCount = 1; + nMin = 0x80; + nUCS4 = *p & 0x1F; + } + else if (*p < 0xF0) + { + nCount = 2; + nMin = 0x800; + nUCS4 = *p & 0xF; + } + else if (*p < 0xF8) + { + nCount = 3; + nMin = 0x10000; + nUCS4 = *p & 7; + } + else if (*p < 0xFC) + { + nCount = 4; + nMin = 0x200000; + nUCS4 = *p & 3; + } + else + { + nCount = 5; + nMin = 0x4000000; + nUCS4 = *p & 1; + } + ++p; + + for (; nCount-- > 0; ++p) + if ((*p & 0xC0) == 0x80) + nUCS4 = nUCS4 << 6 | *p & 0x3F; + else + return false; + + if (nUCS4 < nMin || nUCS4 > 0x10FFFF) + return false; + + if (eEncoding >= RTL_TEXTENCODING_UCS4) + rCharacter = nUCS4; + else + { + sal_Unicode aUTF16[2]; + const sal_Unicode * pUTF16End = putUTF32Character(aUTF16, nUCS4); + sal_Size nSize; + sal_Char * pBuffer = convertFromUnicode(aUTF16, pUTF16End, eEncoding, + nSize); + if (!pBuffer) + return false; + DBG_ASSERT(nSize == 1, + "INetMIME::translateUTF8Char(): Bad conversion"); + rCharacter = *pBuffer; + delete[] pBuffer; + } + rBegin = p; + return true; +} + +//============================================================================ +// static +ByteString INetMIME::decodeUTF8(const ByteString & rText, + rtl_TextEncoding eEncoding) +{ + const sal_Char * p = rText.GetBuffer(); + const sal_Char * pEnd = p + rText.Len(); + ByteString sDecoded; + while (p != pEnd) + { + sal_uInt32 nCharacter; + if (translateUTF8Char(p, pEnd, eEncoding, nCharacter)) + sDecoded += sal_Char(nCharacter); + else + sDecoded += sal_Char(*p++); + } + return sDecoded; +} + +//============================================================================ +// static +UniString INetMIME::decodeHeaderFieldBody(HeaderFieldType eType, + const ByteString & rBody) +{ + // Due to a bug in INetCoreRFC822MessageStream::ConvertTo7Bit(), old + // versions of StarOffice send mails with header fields where encoded + // words can be preceded by '=', ',', '.', '"', or '(', and followed by + // '=', ',', '.', '"', ')', without any required white space in between. + // And there appear to exist some broken mailers that only encode single + // letters within words, like "Appel + // =?iso-8859-1?Q?=E0?=t=?iso-8859-1?Q?=E9?=moin", so it seems best to + // detect encoded words even when not propperly surrounded by white space. + // + // Non US-ASCII characters in rBody are treated as ISO-8859-1. + // + // encoded-word = "=?" + // 1*(%x21 / %x23-27 / %x2A-2B / %x2D / %30-39 / %x41-5A / %x5E-7E) + // ["*" 1*8ALPHA *("-" 1*8ALPHA)] "?" + // ("B?" *(4base64) (4base64 / 3base64 "=" / 2base64 "==") + // / "Q?" 1*(%x21-3C / %x3E / %x40-7E / "=" 2HEXDIG)) + // "?=" + // + // base64 = ALPHA / DIGIT / "+" / "/" + + const sal_Char * pBegin = rBody.GetBuffer(); + const sal_Char * pEnd = pBegin + rBody.Len(); + + UniString sDecoded; + const sal_Char * pCopyBegin = pBegin; + + /* bool bStartEncodedWord = true; */ + const sal_Char * pWSPBegin = pBegin; + UniString sEncodedText; + bool bQuotedEncodedText = false; + sal_uInt32 nCommentLevel = 0; + + for (const sal_Char * p = pBegin; p != pEnd;) + { + if (p != pEnd && *p == '=' /* && bStartEncodedWord */) + { + const sal_Char * q = p + 1; + bool bEncodedWord = q != pEnd && *q++ == '?'; + + rtl_TextEncoding eCharsetEncoding; + if (bEncodedWord) + { + const sal_Char * pCharsetBegin = q; + const sal_Char * pLanguageBegin = 0; + int nAlphaCount; + for (bool bDone = false; !bDone;) + if (q == pEnd) + { + bEncodedWord = false; + bDone = true; + } + else + { + sal_Char cChar = *q++; + switch (cChar) + { + case '*': + pLanguageBegin = q - 1; + nAlphaCount = 0; + break; + + case '-': + if (pLanguageBegin != 0) + { + if (nAlphaCount == 0) + pLanguageBegin = 0; + else + nAlphaCount = 0; + } + break; + + case '?': + if (pCharsetBegin == q - 1) + bEncodedWord = false; + else + { + eCharsetEncoding + = getCharsetEncoding( + pCharsetBegin, + pLanguageBegin == 0 + || nAlphaCount == 0 ? + q - 1 : pLanguageBegin); + bEncodedWord = isMIMECharsetEncoding( + eCharsetEncoding); + eCharsetEncoding + = translateFromMIME(eCharsetEncoding); + } + bDone = true; + break; + + default: + if (pLanguageBegin != 0 + && (!isAlpha(cChar) || ++nAlphaCount > 8)) + pLanguageBegin = 0; + break; + } + } + } + + bool bEncodingB; + if (bEncodedWord) + if (q == pEnd) + bEncodedWord = false; + else + switch (*q++) + { + case 'B': + case 'b': + bEncodingB = true; + break; + + case 'Q': + case 'q': + bEncodingB = false; + break; + + default: + bEncodedWord = false; + break; + } + + bEncodedWord = bEncodedWord && q != pEnd && *q++ == '?'; + + ByteString sText; + if (bEncodedWord) + if (bEncodingB) + for (bool bDone = false; !bDone;) + { + if (pEnd - q < 4) + { + bEncodedWord = false; + bDone = true; + } + else + { + bool bFinal = false; + int nCount = 3; + sal_uInt32 nValue = 0; + for (int nShift = 18; nShift >= 0; nShift -= 6) + { + int nWeight = getBase64Weight(*q++); + if (nWeight == -2) + { + bEncodedWord = false; + bDone = true; + break; + } + if (nWeight == -1) + { + if (!bFinal) + { + if (nShift >= 12) + { + bEncodedWord = false; + bDone = true; + break; + } + bFinal = true; + nCount = nShift == 6 ? 2 : 1; + } + } + else + nValue |= nWeight << nShift; + } + if (bEncodedWord) + { + for (int nShift = 16; nCount-- > 0; + nShift -= 8) + sText += sal_Char(nValue >> nShift + & 0xFF); + if (*q == '?') + { + ++q; + bDone = true; + } + if (bFinal && !bDone) + { + bEncodedWord = false; + bDone = true; + } + } + } + } + else + { + const sal_Char * pEncodedTextBegin = q; + const sal_Char * pEncodedTextCopyBegin = q; + for (bool bDone = false; !bDone;) + if (q == pEnd) + { + bEncodedWord = false; + bDone = true; + } + else + { + sal_uInt32 nChar = *q++; + switch (nChar) + { + case '=': + { + if (pEnd - q < 2) + { + bEncodedWord = false; + bDone = true; + break; + } + int nDigit1 = getHexWeight(q[0]); + int nDigit2 = getHexWeight(q[1]); + if (nDigit1 < 0 || nDigit2 < 0) + { + bEncodedWord = false; + bDone = true; + break; + } + sText + += rBody. + Copy( + pEncodedTextCopyBegin + - pBegin, + q - 1 + - pEncodedTextCopyBegin); + sText += sal_Char(nDigit1 << 4 | nDigit2); + q += 2; + pEncodedTextCopyBegin = q; + break; + } + + case '?': + if (q - pEncodedTextBegin > 1) + sText + += rBody. + Copy( + pEncodedTextCopyBegin + - pBegin, + q - 1 + - pEncodedTextCopyBegin); + else + bEncodedWord = false; + bDone = true; + break; + + case '_': + sText + += rBody. + Copy( + pEncodedTextCopyBegin + - pBegin, + q - 1 + - pEncodedTextCopyBegin); + sText += ' '; + pEncodedTextCopyBegin = q; + break; + + default: + if (!isVisible(nChar)) + { + bEncodedWord = false; + bDone = true; + } + break; + } + } + } + + bEncodedWord = bEncodedWord && q != pEnd && *q++ == '='; + +// if (bEncodedWord && q != pEnd) +// switch (*q) +// { +// case '\t': +// case ' ': +// case '"': +// case ')': +// case ',': +// case '.': +// case '=': +// break; +// +// default: +// bEncodedWord = false; +// break; +// } + + sal_Unicode * pUnicodeBuffer; + sal_Size nUnicodeSize; + if (bEncodedWord) + { + pUnicodeBuffer + = convertToUnicode(sText.GetBuffer(), + sText.GetBuffer() + sText.Len(), + eCharsetEncoding, nUnicodeSize); + if (pUnicodeBuffer == 0) + bEncodedWord = false; + } + + if (bEncodedWord) + { + appendISO88591(sDecoded, pCopyBegin, pWSPBegin); + if (eType == HEADER_FIELD_TEXT) + sDecoded.Append(pUnicodeBuffer, nUnicodeSize); + else if (nCommentLevel == 0) + { + sEncodedText.Append(pUnicodeBuffer, nUnicodeSize); + if (!bQuotedEncodedText) + { + const sal_Unicode * pTextPtr = pUnicodeBuffer; + const sal_Unicode * pTextEnd = pTextPtr + + nUnicodeSize; + for (; pTextPtr != pTextEnd; ++pTextPtr) + if (!isEncodedWordTokenChar(*pTextPtr)) + { + bQuotedEncodedText = true; + break; + } + } + } + else + { + const sal_Unicode * pTextPtr = pUnicodeBuffer; + const sal_Unicode * pTextEnd = pTextPtr + nUnicodeSize; + for (; pTextPtr != pTextEnd; ++pTextPtr) + { + switch (*pTextPtr) + { + case '(': + case ')': + case '\\': + case '\x0D': + case '=': + sDecoded += '\\'; + break; + } + sDecoded += *pTextPtr; + } + } + delete[] pUnicodeBuffer; + p = q; + pCopyBegin = p; + + pWSPBegin = p; + while (p != pEnd && isWhiteSpace(*p)) + ++p; + /* bStartEncodedWord = p != pWSPBegin; */ + continue; + } + } + + if (sEncodedText.Len() != 0) + { + if (bQuotedEncodedText) + { + sDecoded += '"'; + const sal_Unicode * pTextPtr = sEncodedText.GetBuffer(); + const sal_Unicode * pTextEnd = pTextPtr + sEncodedText.Len(); + for (;pTextPtr != pTextEnd; ++pTextPtr) + { + switch (*pTextPtr) + { + case '"': + case '\\': + case '\x0D': + sDecoded += '\\'; + break; + } + sDecoded += *pTextPtr; + } + sDecoded += '"'; + } + else + sDecoded += sEncodedText; + sEncodedText.Erase(); + bQuotedEncodedText = false; + } + + if (p == pEnd) + break; + + switch (*p++) + { +// case '\t': +// case ' ': +// case ',': +// case '.': +// case '=': +// bStartEncodedWord = true; +// break; + + case '"': + if (eType != HEADER_FIELD_TEXT && nCommentLevel == 0) + { + const sal_Char * pQuotedStringEnd + = skipQuotedString(p - 1, pEnd); + p = pQuotedStringEnd == p - 1 ? pEnd : pQuotedStringEnd; + } + /* bStartEncodedWord = true; */ + break; + + case '(': + if (eType != HEADER_FIELD_TEXT) + ++nCommentLevel; + /* bStartEncodedWord = true; */ + break; + + case ')': + if (nCommentLevel > 0) + --nCommentLevel; + /* bStartEncodedWord = false; */ + break; + + default: + { + const sal_Char * pUTF8Begin = p - 1; + const sal_Char * pUTF8End = pUTF8Begin; + sal_uInt32 nCharacter; + if (translateUTF8Char(pUTF8End, pEnd, RTL_TEXTENCODING_UCS4, + nCharacter)) + { + appendISO88591(sDecoded, pCopyBegin, p - 1); + sal_Unicode aUTF16Buf[2]; + xub_StrLen nUTF16Len = putUTF32Character(aUTF16Buf, + nCharacter) + - aUTF16Buf; + sDecoded.Append(aUTF16Buf, nUTF16Len); + p = pUTF8End; + pCopyBegin = p; + } + /* bStartEncodedWord = false; */ + break; + } + } + pWSPBegin = p; + } + + appendISO88591(sDecoded, pCopyBegin, pEnd); + return sDecoded; +} + +//============================================================================ +// +// INetMIMEOutputSink +// +//============================================================================ + +// virtual +sal_Size INetMIMEOutputSink::writeSequence(const sal_Char * pSequence) +{ + sal_Size nLength = rtl_str_getLength(pSequence); + writeSequence(pSequence, pSequence + nLength); + return nLength; +} + +//============================================================================ +// virtual +void INetMIMEOutputSink::writeSequence(const sal_uInt32 * pBegin, + const sal_uInt32 * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEOutputSink::writeSequence(): Bad sequence"); + + sal_Char * pBufferBegin = new sal_Char[pEnd - pBegin]; + sal_Char * pBufferEnd = pBufferBegin; + while (pBegin != pEnd) + { + DBG_ASSERT(*pBegin < 256, + "INetMIMEOutputSink::writeSequence(): Bad octet"); + *pBufferEnd++ = sal_Char(*pBegin++); + } + writeSequence(pBufferBegin, pBufferEnd); + delete[] pBufferBegin; +} + +//============================================================================ +// virtual +void INetMIMEOutputSink::writeSequence(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEOutputSink::writeSequence(): Bad sequence"); + + sal_Char * pBufferBegin = new sal_Char[pEnd - pBegin]; + sal_Char * pBufferEnd = pBufferBegin; + while (pBegin != pEnd) + { + DBG_ASSERT(*pBegin < 256, + "INetMIMEOutputSink::writeSequence(): Bad octet"); + *pBufferEnd++ = sal_Char(*pBegin++); + } + writeSequence(pBufferBegin, pBufferEnd); + delete[] pBufferBegin; +} + +//============================================================================ +// virtual +ErrCode INetMIMEOutputSink::getError() const +{ + return ERRCODE_NONE; +} + +//============================================================================ +void INetMIMEOutputSink::writeLineEnd() +{ + static const sal_Char aCRLF[2] = { 0x0D, 0x0A }; + writeSequence(aCRLF, aCRLF + 2); + m_nColumn = 0; +} + +//============================================================================ +// +// INetMIMEStringOutputSink +// +//============================================================================ + +// virtual +void INetMIMEStringOutputSink::writeSequence(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEStringOutputSink::writeSequence(): Bad sequence"); + + m_bOverflow = m_bOverflow + || pEnd - pBegin > STRING_MAXLEN - m_aBuffer.Len(); + if (!m_bOverflow) + m_aBuffer.Append(pBegin, pEnd - pBegin); +} + +//============================================================================ +// virtual +ErrCode INetMIMEStringOutputSink::getError() const +{ + return m_bOverflow ? ERRCODE_IO_OUTOFMEMORY : ERRCODE_NONE; +} + +//============================================================================ +// +// INetMIMEUnicodeOutputSink +// +//============================================================================ + +// virtual +void INetMIMEUnicodeOutputSink::writeSequence(const sal_Char * pBegin, + const sal_Char * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEUnicodeOutputSink::writeSequence(): Bad sequence"); + + sal_Unicode * pBufferBegin = new sal_Unicode[pEnd - pBegin]; + sal_Unicode * pBufferEnd = pBufferBegin; + while (pBegin != pEnd) + *pBufferEnd++ = sal_uChar(*pBegin++); + writeSequence(pBufferBegin, pBufferEnd); + delete[] pBufferBegin; +} + +//============================================================================ +// virtual +void INetMIMEUnicodeOutputSink::writeSequence(const sal_uInt32 * pBegin, + const sal_uInt32 * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEUnicodeOutputSink::writeSequence(): Bad sequence"); + + sal_Unicode * pBufferBegin = new sal_Unicode[pEnd - pBegin]; + sal_Unicode * pBufferEnd = pBufferBegin; + while (pBegin != pEnd) + { + DBG_ASSERT(*pBegin < 256, + "INetMIMEOutputSink::writeSequence(): Bad octet"); + *pBufferEnd++ = sal_Unicode(*pBegin++); + } + writeSequence(pBufferBegin, pBufferEnd); + delete[] pBufferBegin; +} + +//============================================================================ +// virtual +void INetMIMEUnicodeOutputSink::writeSequence(const sal_Unicode * pBegin, + const sal_Unicode * pEnd) +{ + DBG_ASSERT(pBegin && pBegin <= pEnd, + "INetMIMEUnicodeOutputSink::writeSequence(): Bad sequence"); + + m_bOverflow = m_bOverflow + || pEnd - pBegin > STRING_MAXLEN - m_aBuffer.Len(); + if (!m_bOverflow) + m_aBuffer.Append(pBegin, pEnd - pBegin); +} + +//============================================================================ +// virtual +ErrCode INetMIMEUnicodeOutputSink::getError() const +{ + return m_bOverflow ? ERRCODE_IO_OUTOFMEMORY : ERRCODE_NONE; +} + +//============================================================================ +// +// INetMIMEEncodedWordOutputSink +// +//============================================================================ + +static const sal_Char aEscape[128] + = { INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x00 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x01 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x02 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x03 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x04 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x05 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x06 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x07 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x08 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x09 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0A + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0B + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0C + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0D + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0E + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x0F + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x10 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x11 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x12 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x13 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x14 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x15 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x16 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x17 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x18 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x19 + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1A + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1B + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1C + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1D + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1E + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // 0x1F + 0, // ' ' + 0, // '!' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '"' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '#' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '$' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '%' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '&' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ''' + INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '(' + INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ')' + 0, // '*' + 0, // '+' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ',' + 0, // '-' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '.' + 0, // '/' + 0, // '0' + 0, // '1' + 0, // '2' + 0, // '3' + 0, // '4' + 0, // '5' + 0, // '6' + 0, // '7' + 0, // '8' + 0, // '9' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ':' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ';' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '<' + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '=' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '>' + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '?' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '@' + 0, // 'A' + 0, // 'B' + 0, // 'C' + 0, // 'D' + 0, // 'E' + 0, // 'F' + 0, // 'G' + 0, // 'H' + 0, // 'I' + 0, // 'J' + 0, // 'K' + 0, // 'L' + 0, // 'M' + 0, // 'N' + 0, // 'O' + 0, // 'P' + 0, // 'Q' + 0, // 'R' + 0, // 'S' + 0, // 'T' + 0, // 'U' + 0, // 'V' + 0, // 'W' + 0, // 'X' + 0, // 'Y' + 0, // 'Z' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '[' + INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '\' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // ']' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '^' + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '_' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '`' + 0, // 'a' + 0, // 'b' + 0, // 'c' + 0, // 'd' + 0, // 'e' + 0, // 'f' + 0, // 'g' + 0, // 'h' + 0, // 'i' + 0, // 'j' + 0, // 'k' + 0, // 'l' + 0, // 'm' + 0, // 'n' + 0, // 'o' + 0, // 'p' + 0, // 'q' + 0, // 'r' + 0, // 's' + 0, // 't' + 0, // 'u' + 0, // 'v' + 0, // 'w' + 0, // 'x' + 0, // 'y' + 0, // 'z' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '{' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '|' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '}' + INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE, // '~' + INetMIMEEncodedWordOutputSink::CONTEXT_TEXT | INetMIMEEncodedWordOutputSink::CONTEXT_COMMENT | INetMIMEEncodedWordOutputSink::CONTEXT_PHRASE }; // DEL + +inline bool +INetMIMEEncodedWordOutputSink::needsEncodedWordEscape(sal_uInt32 nChar) const +{ + return !INetMIME::isUSASCII(nChar) || aEscape[nChar] & m_eContext; +} + +//============================================================================ +void INetMIMEEncodedWordOutputSink::finish(bool bWriteTrailer) +{ + if (m_eInitialSpace == SPACE_ALWAYS && m_nExtraSpaces == 0) + m_nExtraSpaces = 1; + + if (m_eEncodedWordState == STATE_SECOND_EQUALS) + { + // If the text is already an encoded word, copy it verbatim: + sal_uInt32 nSize = m_pBufferEnd - m_pBuffer; + switch (m_ePrevCoding) + { + case CODING_QUOTED: + m_rSink << '"'; + case CODING_NONE: + if (m_eInitialSpace == SPACE_ENCODED && m_nExtraSpaces == 0) + m_nExtraSpaces = 1; + for (; m_nExtraSpaces > 1; --m_nExtraSpaces) + { + if (m_rSink.getColumn() >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + if (m_nExtraSpaces == 1) + { + if (m_rSink.getColumn() + nSize + >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + break; + + case CODING_ENCODED: + { + const sal_Char * pCharsetName + = INetMIME::getCharsetName(m_ePrevMIMEEncoding); + while (m_nExtraSpaces-- > 0) + { + if (m_rSink.getColumn() + > m_rSink.getLineLengthLimit() - 3) + m_rSink << "?=" << INetMIMEOutputSink::endl << " =?" + << pCharsetName << "?Q?"; + m_rSink << '_'; + } + m_rSink << "?="; + } + case CODING_ENCODED_TERMINATED: + if (m_rSink.getColumn() + nSize + > m_rSink.getLineLengthLimit() - 1) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + break; + } + m_rSink.write(m_pBuffer, m_pBufferEnd); + m_eCoding = CODING_ENCODED_TERMINATED; + } + else + { + // If the text itself is too long to fit into a single line, make it + // into multiple encoded words: + switch (m_eCoding) + { + case CODING_NONE: + if (m_nExtraSpaces == 0) + { + DBG_ASSERT(m_ePrevCoding == CODING_NONE + || m_pBuffer == m_pBufferEnd, + "INetMIMEEncodedWordOutputSink::finish():" + " Bad state"); + if (m_rSink.getColumn() + (m_pBufferEnd - m_pBuffer) + > m_rSink.getLineLengthLimit()) + m_eCoding = CODING_ENCODED; + } + else if (m_pBufferEnd - m_pBuffer + > m_rSink.getLineLengthLimit() - 1) + m_eCoding = CODING_ENCODED; + break; + + case CODING_QUOTED: + if (m_nExtraSpaces == 0) + { + DBG_ASSERT(m_ePrevCoding == CODING_NONE, + "INetMIMEEncodedWordOutputSink::finish():" + " Bad state"); + if (m_rSink.getColumn() + (m_pBufferEnd - m_pBuffer) + + m_nQuotedEscaped + > m_rSink.getLineLengthLimit() - 2) + m_eCoding = CODING_ENCODED; + } + else if ((m_pBufferEnd - m_pBuffer) + m_nQuotedEscaped + > m_rSink.getLineLengthLimit() - 3) + m_eCoding = CODING_ENCODED; + break; + } + + switch (m_eCoding) + { + case CODING_NONE: + switch (m_ePrevCoding) + { + case CODING_QUOTED: + if (m_rSink.getColumn() + m_nExtraSpaces + + (m_pBufferEnd - m_pBuffer) + < m_rSink.getLineLengthLimit()) + m_eCoding = CODING_QUOTED; + else + m_rSink << '"'; + break; + + case CODING_ENCODED: + m_rSink << "?="; + break; + } + for (; m_nExtraSpaces > 1; --m_nExtraSpaces) + { + if (m_rSink.getColumn() >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + if (m_nExtraSpaces == 1) + { + if (m_rSink.getColumn() + (m_pBufferEnd - m_pBuffer) + >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + m_rSink.write(m_pBuffer, m_pBufferEnd); + if (m_eCoding == CODING_QUOTED && bWriteTrailer) + { + m_rSink << '"'; + m_eCoding = CODING_NONE; + } + break; + + case CODING_QUOTED: + { + bool bInsertLeadingQuote = true; + sal_uInt32 nSize = (m_pBufferEnd - m_pBuffer) + + m_nQuotedEscaped + 2; + switch (m_ePrevCoding) + { + case CODING_QUOTED: + if (m_rSink.getColumn() + m_nExtraSpaces + nSize - 1 + < m_rSink.getLineLengthLimit()) + { + bInsertLeadingQuote = false; + --nSize; + } + else + m_rSink << '"'; + break; + + case CODING_ENCODED: + m_rSink << "?="; + break; + } + for (; m_nExtraSpaces > 1; --m_nExtraSpaces) + { + if (m_rSink.getColumn() >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + if (m_nExtraSpaces == 1) + { + if (m_rSink.getColumn() + nSize + >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + if (bInsertLeadingQuote) + m_rSink << '"'; + for (const sal_Unicode * p = m_pBuffer; p != m_pBufferEnd; + ++p) + { + if (INetMIME::needsQuotedStringEscape(*p)) + m_rSink << '\\'; + m_rSink << sal_Char(*p); + } + if (bWriteTrailer) + { + m_rSink << '"'; + m_eCoding = CODING_NONE; + } + break; + } + + case CODING_ENCODED: + { + rtl_TextEncoding eCharsetEncoding + = m_pEncodingList-> + getPreferredEncoding(RTL_TEXTENCODING_UTF8); + rtl_TextEncoding eMIMEEncoding + = INetMIME::translateToMIME(eCharsetEncoding); + + // The non UTF-8 code will only work for stateless single byte + // character encodings (see also below): + sal_Char * pTargetBuffer; + sal_Size nTargetSize; + sal_uInt32 nSize; + if (eMIMEEncoding == RTL_TEXTENCODING_UTF8) + { + nSize = 0; + for (sal_Unicode const * p = m_pBuffer; + p != m_pBufferEnd;) + { + sal_uInt32 nUTF32 + = INetMIME::getUTF32Character(p, m_pBufferEnd); + nSize += needsEncodedWordEscape(nUTF32) ? + 3 * INetMIME::getUTF8OctetCount(nUTF32) : + 1; + // only US-ASCII characters (that are converted to + // a single byte by UTF-8) need no encoded word + // escapes... + } + } + else + { + rtl_UnicodeToTextConverter hConverter + = rtl_createUnicodeToTextConverter(eCharsetEncoding); + rtl_UnicodeToTextContext hContext + = rtl_createUnicodeToTextContext(hConverter); + for (sal_Size nBufferSize = m_pBufferEnd - m_pBuffer;; + nBufferSize += nBufferSize / 3 + 1) + { + pTargetBuffer = new sal_Char[nBufferSize]; + sal_uInt32 nInfo; + sal_Size nSrcCvtBytes; + nTargetSize + = rtl_convertUnicodeToText( + hConverter, hContext, m_pBuffer, + m_pBufferEnd - m_pBuffer, pTargetBuffer, + nBufferSize, + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_IGNORE + | RTL_UNICODETOTEXT_FLAGS_INVALID_IGNORE, + &nInfo, &nSrcCvtBytes); + if (!(nInfo + & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL)) + break; + delete[] pTargetBuffer; + rtl_resetUnicodeToTextContext(hConverter, hContext); + } + rtl_destroyUnicodeToTextContext(hConverter, hContext); + rtl_destroyUnicodeToTextConverter(hConverter); + + nSize = nTargetSize; + for (sal_Size k = 0; k < nTargetSize; ++k) + if (needsEncodedWordEscape(sal_uChar( + pTargetBuffer[k]))) + nSize += 2; + } + + const sal_Char * pCharsetName + = INetMIME::getCharsetName(eMIMEEncoding); + sal_uInt32 nWrapperSize = rtl_str_getLength(pCharsetName) + 7; + // '=?', '?Q?', '?=' + + switch (m_ePrevCoding) + { + case CODING_QUOTED: + m_rSink << '"'; + case CODING_NONE: + if (m_eInitialSpace == SPACE_ENCODED + && m_nExtraSpaces == 0) + m_nExtraSpaces = 1; + nSize += nWrapperSize; + for (; m_nExtraSpaces > 1; --m_nExtraSpaces) + { + if (m_rSink.getColumn() + >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + if (m_nExtraSpaces == 1) + { + if (m_rSink.getColumn() + nSize + >= m_rSink.getLineLengthLimit()) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << ' '; + } + m_rSink << "=?" << pCharsetName << "?Q?"; + break; + + case CODING_ENCODED: + if (m_ePrevMIMEEncoding != eMIMEEncoding + || m_rSink.getColumn() + m_nExtraSpaces + nSize + > m_rSink.getLineLengthLimit() - 2) + { + m_rSink << "?="; + if (m_rSink.getColumn() + nWrapperSize + + m_nExtraSpaces + nSize + > m_rSink.getLineLengthLimit() - 1) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << " =?" << pCharsetName << "?Q?"; + } + while (m_nExtraSpaces-- > 0) + { + if (m_rSink.getColumn() + > m_rSink.getLineLengthLimit() - 3) + m_rSink << "?=" << INetMIMEOutputSink::endl + << " =?" << pCharsetName << "?Q?"; + m_rSink << '_'; + } + break; + + case CODING_ENCODED_TERMINATED: + if (m_rSink.getColumn() + nWrapperSize + + m_nExtraSpaces + nSize + > m_rSink.getLineLengthLimit() - 1) + m_rSink << INetMIMEOutputSink::endl; + m_rSink << " =?" << pCharsetName << "?Q?"; + while (m_nExtraSpaces-- > 0) + { + if (m_rSink.getColumn() + > m_rSink.getLineLengthLimit() - 3) + m_rSink << "?=" << INetMIMEOutputSink::endl + << " =?" << pCharsetName << "?Q?"; + m_rSink << '_'; + } + break; + } + + // The non UTF-8 code will only work for stateless single byte + // character encodings (see also above): + if (eMIMEEncoding == RTL_TEXTENCODING_UTF8) + { + bool bInitial = true; + for (sal_Unicode const * p = m_pBuffer; + p != m_pBufferEnd;) + { + sal_uInt32 nUTF32 + = INetMIME::getUTF32Character(p, m_pBufferEnd); + bool bEscape = needsEncodedWordEscape(nUTF32); + sal_uInt32 nWidth + = bEscape ? + 3 * INetMIME::getUTF8OctetCount(nUTF32) : 1; + // only US-ASCII characters (that are converted to + // a single byte by UTF-8) need no encoded word + // escapes... + if (!bInitial + && m_rSink.getColumn() + nWidth + 2 + > m_rSink.getLineLengthLimit()) + m_rSink << "?=" << INetMIMEOutputSink::endl + << " =?" << pCharsetName << "?Q?"; + if (bEscape) + { + DBG_ASSERT( + nUTF32 < 0x10FFFF, + "INetMIMEEncodedWordOutputSink::finish():" + " Bad char"); + if (nUTF32 < 0x80) + INetMIME::writeEscapeSequence(m_rSink, + nUTF32); + else if (nUTF32 < 0x800) + { + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 6 + | 0xC0); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 & 0x3F + | 0x80); + } + else if (nUTF32 < 0x10000) + { + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 12 + | 0xE0); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 6 + & 0x3F + | 0x80); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 & 0x3F + | 0x80); + } + else + { + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 18 + | 0xF0); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 12 + & 0x3F + | 0x80); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 >> 6 + & 0x3F + | 0x80); + INetMIME::writeEscapeSequence(m_rSink, + nUTF32 & 0x3F + | 0x80); + } + } + else + m_rSink << sal_Char(nUTF32); + bInitial = false; + } + } + else + { + for (sal_Size k = 0; k < nTargetSize; ++k) + { + sal_uInt32 nUCS4 = sal_uChar(pTargetBuffer[k]); + bool bEscape = needsEncodedWordEscape(nUCS4); + if (k > 0 + && m_rSink.getColumn() + (bEscape ? 5 : 3) + > m_rSink.getLineLengthLimit()) + m_rSink << "?=" << INetMIMEOutputSink::endl + << " =?" << pCharsetName << "?Q?"; + if (bEscape) + INetMIME::writeEscapeSequence(m_rSink, nUCS4); + else + m_rSink << sal_Char(nUCS4); + } + delete[] pTargetBuffer; + } + + if (bWriteTrailer) + { + m_rSink << "?="; + m_eCoding = CODING_ENCODED_TERMINATED; + } + + m_ePrevMIMEEncoding = eMIMEEncoding; + break; + } + } + } + + m_eInitialSpace = SPACE_NO; + m_nExtraSpaces = 0; + m_pEncodingList->reset(); + m_pBufferEnd = m_pBuffer; + m_ePrevCoding = m_eCoding; + m_eCoding = CODING_NONE; + m_nQuotedEscaped = 0; + m_eEncodedWordState = STATE_INITIAL; +} + +//============================================================================ +INetMIMEEncodedWordOutputSink::~INetMIMEEncodedWordOutputSink() +{ + rtl_freeMemory(m_pBuffer); + delete m_pEncodingList; +} + +//============================================================================ +INetMIMEEncodedWordOutputSink & +INetMIMEEncodedWordOutputSink::operator <<(sal_uInt32 nChar) +{ + if (nChar == ' ') + { + if (m_pBufferEnd != m_pBuffer) + finish(false); + ++m_nExtraSpaces; + } + else + { + // Check for an already encoded word: + switch (m_eEncodedWordState) + { + case STATE_INITIAL: + if (nChar == '=') + m_eEncodedWordState = STATE_FIRST_EQUALS; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_FIRST_EQUALS: + if (nChar == '?') + m_eEncodedWordState = STATE_FIRST_EQUALS; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_FIRST_QUESTION: + if (INetMIME::isEncodedWordTokenChar(nChar)) + m_eEncodedWordState = STATE_CHARSET; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_CHARSET: + if (nChar == '?') + m_eEncodedWordState = STATE_SECOND_QUESTION; + else if (!INetMIME::isEncodedWordTokenChar(nChar)) + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_SECOND_QUESTION: + if (nChar == 'B' || nChar == 'Q' + || nChar == 'b' || nChar == 'q') + m_eEncodedWordState = STATE_ENCODING; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_ENCODING: + if (nChar == '?') + m_eEncodedWordState = STATE_THIRD_QUESTION; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_THIRD_QUESTION: + if (INetMIME::isVisible(nChar) && nChar != '?') + m_eEncodedWordState = STATE_ENCODED_TEXT; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_ENCODED_TEXT: + if (nChar == '?') + m_eEncodedWordState = STATE_FOURTH_QUESTION; + else if (!INetMIME::isVisible(nChar)) + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_FOURTH_QUESTION: + if (nChar == '=') + m_eEncodedWordState = STATE_SECOND_EQUALS; + else + m_eEncodedWordState = STATE_BAD; + break; + + case STATE_SECOND_EQUALS: + m_eEncodedWordState = STATE_BAD; + break; + } + + // Update encoding: + m_pEncodingList->includes(nChar); + + // Update coding: + enum { TENQ = 1, // CONTEXT_TEXT, CODING_ENCODED + CENQ = 2, // CONTEXT_COMMENT, CODING_ENCODED + PQTD = 4, // CONTEXT_PHRASE, CODING_QUOTED + PENQ = 8 }; // CONTEXT_PHRASE, CODING_ENCODED + static const sal_Char aMinimal[128] + = { TENQ | CENQ | PENQ, // 0x00 + TENQ | CENQ | PENQ, // 0x01 + TENQ | CENQ | PENQ, // 0x02 + TENQ | CENQ | PENQ, // 0x03 + TENQ | CENQ | PENQ, // 0x04 + TENQ | CENQ | PENQ, // 0x05 + TENQ | CENQ | PENQ, // 0x06 + TENQ | CENQ | PENQ, // 0x07 + TENQ | CENQ | PENQ, // 0x08 + TENQ | CENQ | PENQ, // 0x09 + TENQ | CENQ | PENQ, // 0x0A + TENQ | CENQ | PENQ, // 0x0B + TENQ | CENQ | PENQ, // 0x0C + TENQ | CENQ | PENQ, // 0x0D + TENQ | CENQ | PENQ, // 0x0E + TENQ | CENQ | PENQ, // 0x0F + TENQ | CENQ | PENQ, // 0x10 + TENQ | CENQ | PENQ, // 0x11 + TENQ | CENQ | PENQ, // 0x12 + TENQ | CENQ | PENQ, // 0x13 + TENQ | CENQ | PENQ, // 0x14 + TENQ | CENQ | PENQ, // 0x15 + TENQ | CENQ | PENQ, // 0x16 + TENQ | CENQ | PENQ, // 0x17 + TENQ | CENQ | PENQ, // 0x18 + TENQ | CENQ | PENQ, // 0x19 + TENQ | CENQ | PENQ, // 0x1A + TENQ | CENQ | PENQ, // 0x1B + TENQ | CENQ | PENQ, // 0x1C + TENQ | CENQ | PENQ, // 0x1D + TENQ | CENQ | PENQ, // 0x1E + TENQ | CENQ | PENQ, // 0x1F + 0, // ' ' + 0, // '!' + PQTD , // '"' + 0, // '#' + 0, // '$' + 0, // '%' + 0, // '&' + 0, // ''' + CENQ | PQTD , // '(' + CENQ | PQTD , // ')' + 0, // '*' + 0, // '+' + PQTD , // ',' + 0, // '-' + PQTD , // '.' + 0, // '/' + 0, // '0' + 0, // '1' + 0, // '2' + 0, // '3' + 0, // '4' + 0, // '5' + 0, // '6' + 0, // '7' + 0, // '8' + 0, // '9' + PQTD , // ':' + PQTD , // ';' + PQTD , // '<' + 0, // '=' + PQTD , // '>' + 0, // '?' + PQTD , // '@' + 0, // 'A' + 0, // 'B' + 0, // 'C' + 0, // 'D' + 0, // 'E' + 0, // 'F' + 0, // 'G' + 0, // 'H' + 0, // 'I' + 0, // 'J' + 0, // 'K' + 0, // 'L' + 0, // 'M' + 0, // 'N' + 0, // 'O' + 0, // 'P' + 0, // 'Q' + 0, // 'R' + 0, // 'S' + 0, // 'T' + 0, // 'U' + 0, // 'V' + 0, // 'W' + 0, // 'X' + 0, // 'Y' + 0, // 'Z' + PQTD , // '[' + CENQ | PQTD , // '\' + PQTD , // ']' + 0, // '^' + 0, // '_' + 0, // '`' + 0, // 'a' + 0, // 'b' + 0, // 'c' + 0, // 'd' + 0, // 'e' + 0, // 'f' + 0, // 'g' + 0, // 'h' + 0, // 'i' + 0, // 'j' + 0, // 'k' + 0, // 'l' + 0, // 'm' + 0, // 'n' + 0, // 'o' + 0, // 'p' + 0, // 'q' + 0, // 'r' + 0, // 's' + 0, // 't' + 0, // 'u' + 0, // 'v' + 0, // 'w' + 0, // 'x' + 0, // 'y' + 0, // 'z' + 0, // '{' + 0, // '|' + 0, // '}' + 0, // '~' + TENQ | CENQ | PENQ }; // DEL + Coding eNewCoding = !INetMIME::isUSASCII(nChar) ? CODING_ENCODED : + m_eContext == CONTEXT_PHRASE ? + Coding(aMinimal[nChar] >> 2) : + aMinimal[nChar] & m_eContext ? CODING_ENCODED : + CODING_NONE; + if (eNewCoding > m_eCoding) + m_eCoding = eNewCoding; + if (m_eCoding == CODING_QUOTED + && INetMIME::needsQuotedStringEscape(nChar)) + ++m_nQuotedEscaped; + + // Append to buffer: + if (sal_uInt32(m_pBufferEnd - m_pBuffer) == m_nBufferSize) + { + m_pBuffer + = static_cast< sal_Unicode * >( + rtl_reallocateMemory(m_pBuffer, + (m_nBufferSize + BUFFER_SIZE) + * sizeof (sal_Unicode))); + m_pBufferEnd = m_pBuffer + m_nBufferSize; + m_nBufferSize += BUFFER_SIZE; + } + *m_pBufferEnd++ = sal_Unicode(nChar); + } + return *this; +} + +//============================================================================ +// +// INetContentTypeParameterList +// +//============================================================================ + +void INetContentTypeParameterList::Clear() +{ + while (Count() > 0) + delete static_cast< INetContentTypeParameter * >(Remove(Count() - 1)); +} + +//============================================================================ +const INetContentTypeParameter * +INetContentTypeParameterList::find(const ByteString & rAttribute) const +{ + for (ULONG i = 0; i < Count(); ++i) + { + const INetContentTypeParameter * pParameter = GetObject(i); + if (pParameter->m_sAttribute.EqualsIgnoreCaseAscii(rAttribute)) + return pParameter; + } + return 0; +} + diff --git a/tools/source/inet/inetmsg.cxx b/tools/source/inet/inetmsg.cxx new file mode 100644 index 000000000000..d34513f62b6c --- /dev/null +++ b/tools/source/inet/inetmsg.cxx @@ -0,0 +1,2945 @@ +/************************************************************************* + * + * $RCSfile: inetmsg.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:07 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _SAL_TYPES_H_ +#include <sal/types.h> +#endif + +#ifndef _RTL_CHAR_H_ +#include <rtl/char.h> +#endif + +#ifndef _DATETIME_HXX +#include <datetime.hxx> +#endif +#ifndef _TOOLS_INETMIME_HXX +#include <inetmime.hxx> +#endif +#ifndef _TOOLS_INETMSG_HXX +#include <inetmsg.hxx> +#endif +#ifndef _TOOLS_INETSTRM_HXX +#include <inetstrm.hxx> +#endif + +#include <stdio.h> + +/*======================================================================= + * + * INetMessage Implementation. + * + *=====================================================================*/ +#define CONSTASCII_STRINGPARAM(a) (a), RTL_TEXTENCODING_ASCII_US +#define HEADERFIELD INetMessageHeader + +/* + * ~INetMessage. + */ +INetMessage::~INetMessage (void) +{ + ListCleanup_Impl(); +} + +/* + * ListCleanup_Impl. + */ +void INetMessage::ListCleanup_Impl (void) +{ + // Cleanup. + ULONG i, n = m_aHeaderList.Count(); + for (i = 0; i < n; i++) + delete ((HEADERFIELD*)(m_aHeaderList.GetObject(i))); + m_aHeaderList.Clear(); +} + +/* + * ListCopy. + */ +void INetMessage::ListCopy (const INetMessage &rMsg) +{ + if (!(this == &rMsg)) + { + // Cleanup. + ListCleanup_Impl(); + + // Copy. + ULONG i, n = rMsg.GetHeaderCount(); + for (i = 0; i < n; i++) + { + HEADERFIELD *p = (HEADERFIELD*)(rMsg.m_aHeaderList.GetObject(i)); + m_aHeaderList.Insert (new HEADERFIELD(*p), LIST_APPEND); + } + } +} + +/* + * SetHeaderField_Impl. + */ +void INetMessage::SetHeaderField_Impl ( + INetMIME::HeaderFieldType eType, + const ByteString &rName, + const UniString &rValue, + ULONG &rnIndex) +{ + INetMIMEStringOutputSink aSink (0, STRING_MAXLEN); + INetMIME::writeHeaderFieldBody ( + aSink, eType, rValue, gsl_getSystemTextEncoding(), false); + SetHeaderField_Impl ( + INetMessageHeader (rName, aSink.takeBuffer()), rnIndex); +} + +/* + * SetHeaderField. + */ +ULONG INetMessage::SetHeaderField ( + const UniString& rName, const UniString& rValue, ULONG nIndex) +{ + ULONG nResult = nIndex; + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + ByteString (rName, RTL_TEXTENCODING_ASCII_US), rValue, + nResult); + return nResult; +} + +/* + * SetHeaderField. + */ +ULONG INetMessage::SetHeaderField ( + const INetMessageHeader &rHeader, ULONG nIndex) +{ + ULONG nResult = nIndex; + SetHeaderField_Impl (rHeader, nResult); + return nResult; +} + + +/* + * operator<< + */ +SvStream& INetMessage::operator<< (SvStream& rStrm) const +{ + rStrm << m_nDocSize; + rStrm.WriteByteString (m_aDocName, RTL_TEXTENCODING_UTF8); + + ULONG i, n = m_aHeaderList.Count(); + rStrm << n; + + for (i = 0; i < n; i++) + rStrm << *((HEADERFIELD *)(m_aHeaderList.GetObject(i))); + + return rStrm; +} + +/* + * operator>> + */ +SvStream& INetMessage::operator>> (SvStream& rStrm) +{ + // Cleanup. + m_nDocSize = 0; + m_xDocLB.Clear(); + ListCleanup_Impl(); + + // Copy. + rStrm >> m_nDocSize; + rStrm.ReadByteString (m_aDocName, RTL_TEXTENCODING_UTF8); + + ULONG i, n = 0; + rStrm >> n; + + for (i = 0; i < n; i++) + { + HEADERFIELD *p = new HEADERFIELD(); + rStrm >> *p; + m_aHeaderList.Insert (p, LIST_APPEND); + } + + // Done. + return rStrm; +} + +/*======================================================================= + * + * INetMessageHeaderIterator Implementation. + * + *=====================================================================*/ +INetMessageHeaderIterator::INetMessageHeaderIterator ( + const INetMessage& rMsg, const UniString& rHdrName) +{ + ULONG i, n = rMsg.GetHeaderCount(); + for (i = 0; i < n; i++) + { + if (rHdrName.CompareIgnoreCaseToAscii (rMsg.GetHeaderName(i)) == 0) + { + UniString *pValue = new UniString (rMsg.GetHeaderValue(i)); + aValueList.Insert (pValue, LIST_APPEND); + } + } + nValueCount = aValueList.Count(); +} + +INetMessageHeaderIterator::~INetMessageHeaderIterator (void) +{ + ULONG i, n = aValueList.Count(); + for (i = 0; i < n; i++) + delete ((UniString*)(aValueList.GetObject(i))); + aValueList.Clear(); +} + +/*======================================================================= + * + * INetRFC822Message Implementation. + * + *=====================================================================*/ +/* + * _ImplINetRFC822MessageHeaderData. + */ +static const ByteString _ImplINetRFC822MessageHeaderData[] = +{ + ByteString ("BCC"), + ByteString ("CC"), + ByteString ("Comments"), + ByteString ("Date"), + ByteString ("From"), + ByteString ("In-Reply-To"), + ByteString ("Keywords"), + ByteString ("Message-ID"), + ByteString ("References"), + ByteString ("Reply-To"), + ByteString ("Return-Path"), + ByteString ("Subject"), + ByteString ("Sender"), + ByteString ("To"), + ByteString ("X-Mailer"), + ByteString ("Return-Receipt-To") +}; + +#define HDR(n) _ImplINetRFC822MessageHeaderData[(n)] + +/* + * _ImplINetRFC822MessageHeaderState. + */ +enum _ImplINetRFC822MessageHeaderState +{ + INETMSG_RFC822_BEGIN, + INETMSG_RFC822_CHECK, + INETMSG_RFC822_OK, + INETMSG_RFC822_JUNK, + + INETMSG_RFC822_TOKEN_RE, + INETMSG_RFC822_TOKEN_RETURNMINUS, + INETMSG_RFC822_TOKEN_XMINUS, + INETMSG_RFC822_LETTER_C, + INETMSG_RFC822_LETTER_S +}; + +/* + * INetRFC822Message. + */ +INetRFC822Message::INetRFC822Message (void) + : INetMessage() +{ + for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++) + m_nIndex[i] = LIST_ENTRY_NOTFOUND; +} + +INetRFC822Message::INetRFC822Message (const INetRFC822Message& rMsg) + : INetMessage (rMsg) +{ + for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; +} + +/* + * operator= + */ +INetRFC822Message& INetRFC822Message::operator= (const INetRFC822Message& rMsg) +{ + if (this != &rMsg) + { + INetMessage::operator= (rMsg); + + for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; + } + return *this; +} + +/* + * ~INetRFC822Message. + */ +INetRFC822Message::~INetRFC822Message (void) +{ +} + +/* + * <Generate|Parse>DateField and local helper functions. + * + * GenerateDateField. + * Generates a String from Date and Time objects in format: + * Wkd, 00 Mon 0000 00:00:00 [GMT] (rfc822, rfc1123) + * + * ParseDateField. + * Parses a String in (implied) GMT format into class Date and Time objects. + * Four formats are accepted: + * + * [Wkd,] 1*2DIGIT Mon 2*4DIGIT 00:00:00 [GMT] (rfc1123) + * [Wkd,] 00 Mon 0000 00:00:00 [GMT]) (rfc822, rfc1123) + * Weekday, 00-Mon-00 00:00:00 [GMT] (rfc850, rfc1036) + * Wkd Mon 00 00:00:00 0000 [GMT] (ctime) + * 1*DIGIT (delta seconds) + * + */ + +// Months and Weekdays. +static const sal_Char *months[12] = +{ + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +static const sal_Char *wkdays[7] = +{ + "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" +}; + +/* + * GenerateDateField. + */ +BOOL INetRFC822Message::GenerateDateField ( + const DateTime& rDateTime, UniString& rDateFieldW) +{ + // Check arguments. + if (!rDateTime.IsValid() || + (rDateTime.GetSec() > 59) || + (rDateTime.GetMin() > 59) || + (rDateTime.GetHour() > 23) ) return FALSE; + + // Prepare output string. + ByteString rDateField; + + // Insert Date. + rDateField += wkdays[(USHORT)(rDateTime.GetDayOfWeek())]; + rDateField += ", "; + + USHORT nNum = rDateTime.GetDay(); + if (nNum < 10) rDateField += '0'; + rDateField += nNum; + rDateField += ' '; + + rDateField += months[(USHORT)(rDateTime.GetMonth() - 1)]; + rDateField += ' '; + + rDateField += rDateTime.GetYear(); + rDateField += ' '; + + // Insert Time. + nNum = rDateTime.GetHour(); + if (nNum < 10) rDateField += '0'; + rDateField += nNum; + rDateField += ':'; + + nNum = rDateTime.GetMin(); + if (nNum < 10) rDateField += '0'; + rDateField += nNum; + rDateField += ':'; + + nNum = rDateTime.GetSec(); + if (nNum < 10) rDateField += '0'; + rDateField += nNum; + rDateField += " GMT"; + + // Done. + rDateFieldW = UniString (rDateField, RTL_TEXTENCODING_ASCII_US); + return TRUE; +} + +/* + * ParseDateField and local helper functions. + */ +static USHORT ParseNumber (const ByteString& rStr, USHORT& nIndex) +{ + USHORT n = nIndex; + while ((n < rStr.Len()) && rtl_char_isDigit(rStr.GetChar(n))) n++; + + ByteString aNum (rStr.Copy (nIndex, (n - nIndex))); + nIndex = n; + + return (USHORT)(aNum.ToInt32()); +} + +static USHORT ParseMonth (const ByteString& rStr, USHORT& nIndex) +{ + USHORT n = nIndex; + while ((n < rStr.Len()) && rtl_char_isLetter(rStr.GetChar(n))) n++; + + ByteString aMonth (rStr.Copy (nIndex, 3)); + nIndex = n; + + USHORT i; + for (i = 0; i < 12; i++) + if (aMonth.CompareIgnoreCaseToAscii (months[i]) == 0) break; + return (i + 1); +} + +BOOL INetRFC822Message::ParseDateField ( + const UniString& rDateFieldW, DateTime& rDateTime) +{ + ByteString rDateField (rDateFieldW, RTL_TEXTENCODING_ASCII_US); + if (rDateField.Len() == 0) return FALSE; + + if (rDateField.Search (':') != STRING_NOTFOUND) + { + // Some DateTime format. + USHORT nIndex = 0; + + // Skip over <Wkd> or <Weekday>, leading and trailing space. + while ((nIndex < rDateField.Len()) && + (rDateField.GetChar(nIndex) == ' ')) + nIndex++; + + while ( + (nIndex < rDateField.Len()) && + (rtl_char_isLetter (rDateField.GetChar(nIndex)) || + (rDateField.GetChar(nIndex) == ',') )) + nIndex++; + + while ((nIndex < rDateField.Len()) && + (rDateField.GetChar(nIndex) == ' ')) + nIndex++; + + if (rtl_char_isLetter (rDateField.GetChar(nIndex))) + { + // Format: ctime(). + if ((rDateField.Len() - nIndex) < 20) return FALSE; + + rDateTime.SetMonth (ParseMonth (rDateField, nIndex)); nIndex++; + rDateTime.SetDay (ParseNumber (rDateField, nIndex)); nIndex++; + + rDateTime.SetHour (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.SetMin (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.SetSec (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.Set100Sec (0); + + USHORT nYear = ParseNumber (rDateField, nIndex); + if (nYear < 100) nYear += 1900; + rDateTime.SetYear (nYear); + } + else + { + // Format: RFC1036 or RFC1123. + if ((rDateField.Len() - nIndex) < 17) return FALSE; + + rDateTime.SetDay (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.SetMonth (ParseMonth (rDateField, nIndex)); nIndex++; + + USHORT nYear = ParseNumber (rDateField, nIndex); nIndex++; + if (nYear < 100) nYear += 1900; + rDateTime.SetYear (nYear); + + rDateTime.SetHour (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.SetMin (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.SetSec (ParseNumber (rDateField, nIndex)); nIndex++; + rDateTime.Set100Sec (0); + + if ((rDateField.GetChar(nIndex) == '+') || + (rDateField.GetChar(nIndex) == '-') ) + { + // Offset from GMT: "(+|-)HHMM". + BOOL bEast = (rDateField.GetChar(nIndex++) == '+'); + USHORT nOffset = ParseNumber (rDateField, nIndex); + if (nOffset > 0) + { + Time aDiff; + aDiff.SetHour (nOffset / 100); + aDiff.SetMin (nOffset % 100); + aDiff.SetSec (0); + aDiff.Set100Sec (0); + + if (bEast) + rDateTime -= aDiff; + else + rDateTime += aDiff; + } + } + } + } + else if (rDateField.IsNumericAscii()) + { + // Format: delta seconds. + Time aDelta (0); + aDelta.SetTime (rDateField.ToInt32() * 100); + + DateTime aNow; + aNow += aDelta; + aNow.ConvertToUTC(); + + rDateTime.SetDate (aNow.GetDate()); + rDateTime.SetTime (aNow.GetTime()); + } + else + { + // Junk. + return FALSE; + } + + return (rDateTime.IsValid() && + !((rDateTime.GetSec() > 59) || + (rDateTime.GetMin() > 59) || + (rDateTime.GetHour() > 23) )); +} + +/* + * SetHeaderField. + * (Header Field Parser). + */ +ULONG INetRFC822Message::SetHeaderField ( + const INetMessageHeader &rHeader, ULONG nNewIndex) +{ + ByteString aName (rHeader.GetName()); + const sal_Char *pData = aName.GetBuffer(); + const sal_Char *pStop = pData + aName.Len() + 1; + const sal_Char *check = ""; + + ULONG nIdx = LIST_APPEND; + int eState = INETMSG_RFC822_BEGIN; + int eOkState = INETMSG_RFC822_OK; + + while (pData < pStop) + { + switch (eState) + { + case INETMSG_RFC822_BEGIN: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'b': + check = "cc"; + nIdx = INETMSG_RFC822_BCC; + break; + + case 'c': + eState = INETMSG_RFC822_LETTER_C; + break; + + case 'd': + check = "ate"; + nIdx = INETMSG_RFC822_DATE; + break; + + case 'f': + check = "rom"; + nIdx = INETMSG_RFC822_FROM; + break; + + case 'i': + check = "n-reply-to"; + nIdx = INETMSG_RFC822_IN_REPLY_TO; + break; + + case 'k': + check = "eywords"; + nIdx = INETMSG_RFC822_KEYWORDS; + break; + + case 'm': + check = "essage-id"; + nIdx = INETMSG_RFC822_MESSAGE_ID; + break; + + case 'r': + check = "e"; + eOkState = INETMSG_RFC822_TOKEN_RE; + break; + + case 's': + eState = INETMSG_RFC822_LETTER_S; + break; + + case 't': + check = "o"; + nIdx = INETMSG_RFC822_TO; + break; + + case 'x': + check = "-"; + eOkState = INETMSG_RFC822_TOKEN_XMINUS; + break; + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_TOKEN_RE: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'f': + check = "erences"; + nIdx = INETMSG_RFC822_REFERENCES; + break; + + case 'p': + check = "ly-to"; + nIdx = INETMSG_RFC822_REPLY_TO; + break; + + case 't': + check = "urn-"; + eOkState = INETMSG_RFC822_TOKEN_RETURNMINUS; + break; + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_TOKEN_RETURNMINUS: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'p': + check = "ath"; + nIdx = INETMSG_RFC822_RETURN_PATH; + break; + + case 'r': + check = "eceipt-to"; + nIdx = INETMSG_RFC822_RETURN_RECEIPT_TO; + break; + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_TOKEN_XMINUS: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'm': + check = "ailer"; + nIdx = INETMSG_RFC822_X_MAILER; + break; + +#if 0 /* NYI */ + case 'p': + check = "riority"; + eOkState = INETMSG_RFC822_X_PRIORITY; + break; +#endif /* NYI */ + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_LETTER_C: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'c': + check = ""; + nIdx = INETMSG_RFC822_CC; + break; + + case 'o': + check = "mments"; + nIdx = INETMSG_RFC822_COMMENTS; + break; + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_LETTER_S: + eState = INETMSG_RFC822_CHECK; + eOkState = INETMSG_RFC822_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'e': + check = "nder"; + nIdx = INETMSG_RFC822_SENDER; + break; + + case 'u': + check = "bject"; + nIdx = INETMSG_RFC822_SUBJECT; + break; + + default: + eState = INETMSG_RFC822_JUNK; + break; + } + pData++; + break; + + case INETMSG_RFC822_CHECK: + if (*check) + { + while (*pData && *check && + (rtl_char_toLowerCase (*pData) == *check)) + { + pData++; + check++; + } + } + else + { + check = pData; + } + eState = (*check == '\0') ? eOkState : INETMSG_RFC822_JUNK; + break; + + case INETMSG_RFC822_OK: + pData = pStop; + SetHeaderField_Impl ( + HEADERFIELD (HDR(nIdx), rHeader.GetValue()), + m_nIndex[nIdx]); + nNewIndex = m_nIndex[nIdx]; + break; + + default: // INETMSG_RFC822_JUNK + pData = pStop; + nNewIndex = INetMessage::SetHeaderField (rHeader, nNewIndex); + break; + } + } + return nNewIndex; +} + +/* + * Specific Set-Methods. + */ +void INetRFC822Message::SetBCC (const UniString& rBCC) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_BCC), rBCC, + m_nIndex[INETMSG_RFC822_BCC]); +} + +void INetRFC822Message::SetCC (const UniString& rCC) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_CC), rCC, + m_nIndex[INETMSG_RFC822_CC]); +} + +void INetRFC822Message::SetComments (const UniString& rComments) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HDR(INETMSG_RFC822_COMMENTS), rComments, + m_nIndex[INETMSG_RFC822_COMMENTS]); +} + +void INetRFC822Message::SetDate (const UniString& rDate) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_STRUCTURED, + HDR(INETMSG_RFC822_DATE), rDate, + m_nIndex[INETMSG_RFC822_DATE]); +} + +void INetRFC822Message::SetFrom (const UniString& rFrom) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_FROM), rFrom, + m_nIndex[INETMSG_RFC822_FROM]); +} + +void INetRFC822Message::SetInReplyTo (const UniString& rInReplyTo) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, // ??? MESSAGE_ID ??? + HDR(INETMSG_RFC822_IN_REPLY_TO), rInReplyTo, + m_nIndex[INETMSG_RFC822_IN_REPLY_TO]); +} + +void INetRFC822Message::SetKeywords (const UniString& rKeywords) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_PHRASE, + HDR(INETMSG_RFC822_KEYWORDS), rKeywords, + m_nIndex[INETMSG_RFC822_KEYWORDS]); +} + +void INetRFC822Message::SetMessageID (const UniString& rMessageID) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_MESSAGE_ID, + HDR(INETMSG_RFC822_MESSAGE_ID), rMessageID, + m_nIndex[INETMSG_RFC822_MESSAGE_ID]); +} + +void INetRFC822Message::SetReferences (const UniString& rReferences) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_MESSAGE_ID, + HDR(INETMSG_RFC822_REFERENCES), rReferences, + m_nIndex[INETMSG_RFC822_REFERENCES]); +} + +void INetRFC822Message::SetReplyTo (const UniString& rReplyTo) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_REPLY_TO), rReplyTo, + m_nIndex[INETMSG_RFC822_REPLY_TO]); +} + +void INetRFC822Message::SetReturnPath (const UniString& rReturnPath) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_RETURN_PATH), rReturnPath, + m_nIndex[INETMSG_RFC822_RETURN_PATH]); +} + +void INetRFC822Message::SetReturnReceiptTo (const UniString& rValue) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_RETURN_RECEIPT_TO), rValue, + m_nIndex[INETMSG_RFC822_RETURN_RECEIPT_TO]); +} + +void INetRFC822Message::SetSender (const UniString& rSender) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_SENDER), rSender, + m_nIndex[INETMSG_RFC822_SENDER]); +} + +void INetRFC822Message::SetSubject (const UniString& rSubject) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HDR(INETMSG_RFC822_SUBJECT), rSubject, + m_nIndex[INETMSG_RFC822_SUBJECT]); +} + +void INetRFC822Message::SetTo (const UniString& rTo) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_ADDRESS, + HDR(INETMSG_RFC822_TO), rTo, + m_nIndex[INETMSG_RFC822_TO]); +} + +void INetRFC822Message::SetXMailer (const UniString& rXMailer) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HDR(INETMSG_RFC822_X_MAILER), rXMailer, + m_nIndex[INETMSG_RFC822_X_MAILER]); +} + +/* + * operator<< + */ +SvStream& INetRFC822Message::operator<< (SvStream& rStrm) const +{ + INetMessage::operator<< (rStrm); + + for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++) + rStrm << m_nIndex[i]; + + return rStrm; +} + +/* + * operator>> + */ +SvStream& INetRFC822Message::operator>> (SvStream& rStrm) +{ + INetMessage::operator>> (rStrm); + + for (USHORT i = 0; i < INETMSG_RFC822_NUMHDR; i++) + rStrm >> m_nIndex[i]; + + return rStrm; +} + +/*======================================================================= + * + * INetMIMEMessage Implementation. + * + *=====================================================================*/ +/* + * _ImplINetMIMEMessageHeaderData. + */ +static const ByteString _ImplINetMIMEMessageHeaderData[] = +{ + ByteString ("MIME-Version"), + ByteString ("Content-Description"), + ByteString ("Content-Disposition"), + ByteString ("Content-ID"), + ByteString ("Content-Type"), + ByteString ("Content-Transfer-Encoding") +}; + +#define MIMEHDR(n) _ImplINetMIMEMessageHeaderData[(n)] + +/* + * _ImplINetMIMEMessageHeaderState. + */ +enum _ImplINetMIMEMessageHeaderState +{ + INETMSG_MIME_BEGIN, + INETMSG_MIME_CHECK, + INETMSG_MIME_OK, + INETMSG_MIME_JUNK, + + INETMSG_MIME_TOKEN_CONTENT, + INETMSG_MIME_TOKEN_CONTENT_D, + INETMSG_MIME_TOKEN_CONTENT_T +}; + +/* + * INetMIMEMessage. + */ +INetMIMEMessage::INetMIMEMessage (void) + : INetRFC822Message (), + nNumChildren (0), + pParent (NULL), + bHeaderParsed (FALSE) +{ + for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++) + m_nIndex[i] = LIST_ENTRY_NOTFOUND; +} + +INetMIMEMessage::INetMIMEMessage (const INetMIMEMessage& rMsg) + : INetRFC822Message (rMsg) +{ + // Copy. + CopyImp (rMsg); +} + +/* + * operator= + */ +INetMIMEMessage& INetMIMEMessage::operator= ( + const INetMIMEMessage& rMsg) +{ + if (this != &rMsg) + { + // Assign base. + INetRFC822Message::operator= (rMsg); + + // Cleanup. + CleanupImp(); + + // Copy. + CopyImp (rMsg); + } + return *this; +} + +/* + * ~INetMIMEMessage. + */ +INetMIMEMessage::~INetMIMEMessage (void) +{ + // Cleanup. + CleanupImp(); +} + +/* + * CleanupImp. + */ +void INetMIMEMessage::CleanupImp (void) +{ + INetMIMEMessage *pChild = NULL; + while ((pChild = (INetMIMEMessage *)(aChildren.Remove())) != NULL) + if (pChild->pParent == this) delete pChild; +} + +/* + * CopyImp. + */ +void INetMIMEMessage::CopyImp (const INetMIMEMessage& rMsg) +{ + bHeaderParsed = rMsg.bHeaderParsed; + + USHORT i; + for (i = 0; i < INETMSG_MIME_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; + + m_aBoundary = rMsg.m_aBoundary; + nNumChildren = rMsg.nNumChildren; + + for (i = 0; i < rMsg.aChildren.Count(); i++) + { + INetMIMEMessage *pChild = + (INetMIMEMessage *)(rMsg.aChildren.GetObject (i)); + + if (pChild->pParent == &rMsg) + { + pChild = pChild->CreateMessage (*pChild); + pChild->pParent = this; + } + aChildren.Insert (pChild, LIST_APPEND); + } +} + +/* + * CreateMessage. + */ +INetMIMEMessage *INetMIMEMessage::CreateMessage ( + const INetMIMEMessage& rMsg) const +{ + return (new INetMIMEMessage (rMsg)); +} + +/* + * SetHeaderField. + * (Header Field Parser). + */ +ULONG INetMIMEMessage::SetHeaderField ( + const INetMessageHeader &rHeader, ULONG nNewIndex) +{ + ByteString aName (rHeader.GetName()); + const sal_Char *pData = aName.GetBuffer(); + const sal_Char *pStop = pData + aName.Len() + 1; + const sal_Char *check = ""; + + ULONG nIdx = LIST_APPEND; + int eState = INETMSG_MIME_BEGIN; + int eOkState = INETMSG_MIME_OK; + + while (pData < pStop) + { + switch (eState) + { + case INETMSG_MIME_BEGIN: + eState = INETMSG_MIME_CHECK; + eOkState = INETMSG_MIME_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'c': + check = "ontent-"; + eOkState = INETMSG_MIME_TOKEN_CONTENT; + break; + + case 'm': + check = "ime-version"; + nIdx = INETMSG_MIME_VERSION; + break; + + default: + eState = INETMSG_MIME_JUNK; + break; + } + pData++; + break; + + case INETMSG_MIME_TOKEN_CONTENT: + eState = INETMSG_MIME_CHECK; + eOkState = INETMSG_MIME_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'd': + eState = INETMSG_MIME_TOKEN_CONTENT_D; + break; + + case 'i': + check = "d"; + nIdx = INETMSG_MIME_CONTENT_ID; + break; + + case 't': + eState = INETMSG_MIME_TOKEN_CONTENT_T; + break; + + default: + eState = INETMSG_MIME_JUNK; + break; + } + pData++; + break; + + case INETMSG_MIME_TOKEN_CONTENT_D: + eState = INETMSG_MIME_CHECK; + eOkState = INETMSG_MIME_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'e': + check = "scription"; + nIdx = INETMSG_MIME_CONTENT_DESCRIPTION; + break; + + case 'i': + check = "sposition"; + nIdx = INETMSG_MIME_CONTENT_DISPOSITION; + break; + + default: + eState = INETMSG_MIME_JUNK; + break; + } + pData++; + break; + + case INETMSG_MIME_TOKEN_CONTENT_T: + eState = INETMSG_MIME_CHECK; + eOkState = INETMSG_MIME_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'r': + check = "ansfer-encoding"; + nIdx = INETMSG_MIME_CONTENT_TRANSFER_ENCODING; + break; + + case 'y': + check = "pe"; + nIdx = INETMSG_MIME_CONTENT_TYPE; + break; + + default: + eState = INETMSG_MIME_JUNK; + break; + } + pData++; + break; + + case INETMSG_MIME_CHECK: + if (*check) + { + while (*pData && *check && + (rtl_char_toLowerCase (*pData) == *check)) + { + pData++; + check++; + } + } + else + { + check = pData; + } + eState = (*check == '\0') ? eOkState : INETMSG_MIME_JUNK; + break; + + case INETMSG_MIME_OK: + pData = pStop; + SetHeaderField_Impl ( + HEADERFIELD (MIMEHDR(nIdx), rHeader.GetValue()), + m_nIndex[nIdx]); + nNewIndex = m_nIndex[nIdx]; + break; + + default: // INETMSG_MIME_JUNK + pData = pStop; + nNewIndex = INetRFC822Message::SetHeaderField ( + rHeader, nNewIndex); + break; + } + } + return nNewIndex; +} + +/* + * Specific Set-Methods. + */ +void INetMIMEMessage::SetMIMEVersion (const UniString& rVersion) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_VERSION), rVersion, + m_nIndex[INETMSG_MIME_VERSION]); +} + +void INetMIMEMessage::SetContentDescription (const String& rDescription) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_CONTENT_DESCRIPTION), rDescription, + m_nIndex[INETMSG_MIME_CONTENT_DESCRIPTION]); +} + +void INetMIMEMessage::SetContentDisposition (const String& rDisposition) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_CONTENT_DISPOSITION), rDisposition, + m_nIndex[INETMSG_MIME_CONTENT_DISPOSITION]); +} + +void INetMIMEMessage::SetContentID (const String& rID) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_CONTENT_ID), rID, + m_nIndex[INETMSG_MIME_CONTENT_ID]); +} + +void INetMIMEMessage::SetContentType (const String& rType) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_CONTENT_TYPE), rType, + m_nIndex[INETMSG_MIME_CONTENT_TYPE]); +} + +void INetMIMEMessage::SetContentTransferEncoding ( + const String& rEncoding) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + MIMEHDR(INETMSG_MIME_CONTENT_TRANSFER_ENCODING), rEncoding, + m_nIndex[INETMSG_MIME_CONTENT_TRANSFER_ENCODING]); +} + +/* + * GetDefaultContentType. + */ +void INetMIMEMessage::GetDefaultContentType (String& rContentType) +{ + String aDefaultCT ( + "text/plain; charset=us-ascii", RTL_TEXTENCODING_ASCII_US); + if (pParent == NULL) + { + rContentType = aDefaultCT; + } + else + { + String aParentCT (pParent->GetContentType()); + if (aParentCT.Len() == 0) + pParent->GetDefaultContentType (aParentCT); + + if (aParentCT.CompareIgnoreCaseToAscii ("message/", 8) == 0) + { + rContentType = aDefaultCT; + } + else if (aParentCT.CompareIgnoreCaseToAscii ("multipart/", 10) == 0) + { + if (aParentCT.CompareIgnoreCaseToAscii ("multipart/digest") == 0) + rContentType.AssignAscii ("message/rfc822"); + else + rContentType = aDefaultCT; + } + else + { + rContentType = aDefaultCT; + } + } +} + +/* + * EnableAttachChild. + */ +BOOL INetMIMEMessage::EnableAttachChild (INetMessageContainerType eType) +{ + // Check context. + if (IsContainer()) + return FALSE; + + // Setup Content-Type header field. + ByteString aContentType; + switch (eType) + { + case INETMSG_MESSAGE_RFC822: + aContentType = "message/rfc822"; + break; + + case INETMSG_MULTIPART_ALTERNATIVE: + aContentType = "multipart/alternative"; + break; + + case INETMSG_MULTIPART_DIGEST: + aContentType = "multipart/digest"; + break; + + case INETMSG_MULTIPART_PARALLEL: + aContentType = "multipart/parallel"; + break; + + case INETMSG_MULTIPART_RELATED: + aContentType = "multipart/related"; + break; + + case INETMSG_MULTIPART_FORM_DATA: + aContentType = "multipart/form-data"; + break; + + default: + aContentType = "multipart/mixed"; + break; + } + + // Setup boundary for multipart types. + if (aContentType.CompareIgnoreCaseToAscii ("multipart/", 10) == 0) + { + // Generate a unique boundary from current time. + sal_Char sTail[16 + 1]; + Time aCurTime; + sprintf (sTail, "%08X%08X", aCurTime.GetTime(), (ULONG)this); + m_aBoundary = "------------_4D48"; + m_aBoundary += sTail; + + // Append boundary as ContentType parameter. + aContentType += "; boundary="; + aContentType += m_aBoundary; + } + + // Set header fields. + SetMIMEVersion (String (CONSTASCII_STRINGPARAM("1.0"))); + SetContentType (String (aContentType, RTL_TEXTENCODING_ASCII_US)); + SetContentTransferEncoding (String (CONSTASCII_STRINGPARAM("7bit"))); + + // Done. + return TRUE; +} + +/* + * AttachChild. + */ +BOOL INetMIMEMessage::AttachChild ( + INetMIMEMessage& rChildMsg, BOOL bOwner) +{ + if (IsContainer() /*&& rChildMsg.GetContentType().Len() */) + { + if (bOwner) rChildMsg.pParent = this; + aChildren.Insert (&rChildMsg, LIST_APPEND); + nNumChildren = aChildren.Count(); + + return TRUE; + } + return FALSE; +} + +/* + * DetachChild. + */ +BOOL INetMIMEMessage::DetachChild ( + ULONG nIndex, INetMIMEMessage& rChildMsg) const +{ + if (IsContainer()) + { + // Check document stream. + if (GetDocumentLB() == NULL) return FALSE; + SvStream *pDocStrm = new SvStream (GetDocumentLB()); + + // Initialize message buffer. + char pMsgBuffer[1024]; + char *pMsgRead, *pMsgWrite; + pMsgRead = pMsgWrite = pMsgBuffer; + + // Initialize message parser stream. + INetMIMEMessageStream *pMsgStrm = NULL; + + // Check for "multipart/uvw" or "message/xyz". + if (IsMultipart()) + { + // Multipart message body. Initialize multipart delimiters. + ByteString aDelim ("--"); + aDelim += GetMultipartBoundary(); + ByteString aClose = aDelim; + aClose += "--"; + + // Initialize line buffer. + SvMemoryStream aLineBuf; + + // Initialize control variables. + INetMessageStreamState eState = INETMSG_EOL_SCR; + int nCurIndex = -1; + + // Go! + while (nCurIndex < (int)(nIndex + 1)) + { + if ((pMsgRead - pMsgWrite) > 0) + { + // Bytes still in buffer. + if (eState == INETMSG_EOL_FCR) + { + // Check for 2nd line break character. + if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n')) + aLineBuf << *pMsgWrite++; + + // Check current index. + if (nCurIndex == (int)nIndex) + { + // Found requested part. + if (pMsgStrm == NULL) + { + // Create message parser stream. + pMsgStrm = new INetMIMEMessageStream; + pMsgStrm->SetTargetMessage (&rChildMsg); + } + + // Put message down-stream. + int status = pMsgStrm->Write ( + (const sal_Char *) aLineBuf.GetData(), aLineBuf.Tell()); + if (status != INETSTREAM_STATUS_OK) + { + // Cleanup. + delete pDocStrm; + delete pMsgStrm; + + // Finish. + return (!(status == INETSTREAM_STATUS_OK)); + } + } + + // Reset to <Begin-of-Line>. + aLineBuf.Seek (STREAM_SEEK_TO_BEGIN); + eState = INETMSG_EOL_SCR; + } + else if ((*pMsgWrite == '\r') || (*pMsgWrite == '\n')) + { + /* + * Found any line break character. + * Compare buffered line with part/close delimiter. + * Increment current part index upon match. + */ + USHORT nLen = (USHORT)(aLineBuf.Tell() & 0xffff); + if (nLen == aDelim.Len()) + { + if (aDelim.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen) + == COMPARE_EQUAL) nCurIndex++; + } + else if (nLen == aClose.Len()) + { + if (aClose.CompareTo ((const sal_Char *) aLineBuf.GetData(), nLen) + == COMPARE_EQUAL) nCurIndex++; + } + aLineBuf << *pMsgWrite++; + eState = INETMSG_EOL_FCR; + } + else + { + // Insert into line buffer. + aLineBuf << *pMsgWrite; + } + } + else + { + // Buffer empty. Reset to <Begin-of-Buffer>. + pMsgRead = pMsgWrite = pMsgBuffer; + + // Read document stream. + ULONG nRead = pDocStrm->Read ( + pMsgBuffer, sizeof (pMsgBuffer)); + if (nRead > 0) + { + // Set read pointer. + pMsgRead += nRead; + } + else + { + // Premature end. + if (pMsgStrm) + { + // Assume end of requested part. + nCurIndex++; + } + else + { + // Requested part not found. + delete pDocStrm; + return FALSE; + } + } + } + } // while (nCurIndex < (nIndex + 1)) + } + else + { + // Encapsulated message body. Create message parser stream. + pMsgStrm = new INetMIMEMessageStream; + pMsgStrm->SetTargetMessage (&rChildMsg); + + // Initialize control variables. + INetMessageStreamState eState = INETMSG_EOL_BEGIN; + + // Go. + while (eState == INETMSG_EOL_BEGIN) + { + if ((pMsgRead - pMsgWrite) > 0) + { + // Bytes still in buffer. Put message down-stream. + int status = pMsgStrm->Write ( + pMsgBuffer, (pMsgRead - pMsgWrite), NULL); + if (status != INETSTREAM_STATUS_OK) + { + // Cleanup. + delete pDocStrm; + delete pMsgStrm; + + // Finish. + return (!(status == INETSTREAM_STATUS_ERROR)); + } + pMsgWrite = pMsgBuffer + (pMsgRead - pMsgWrite); + } + else + { + // Buffer empty. Reset to <Begin-of-Buffer>. + pMsgRead = pMsgWrite = pMsgBuffer; + + // Read document stream. + ULONG nRead = pDocStrm->Read ( + pMsgBuffer, sizeof (pMsgBuffer)); + if (nRead > 0) + { + // Set read pointer. + pMsgRead += nRead; + } + else + { + // Mark we're done. + eState = INETMSG_EOL_DONE; + } + } + } // while (eState == INETMSG_EOL_BEGIN) + } + + // Done. + if (pDocStrm) delete pDocStrm; + if (pMsgStrm) delete pMsgStrm; + return TRUE; + } + return FALSE; +} + +/* + * operator<< + */ +SvStream& INetMIMEMessage::operator<< (SvStream& rStrm) const +{ + INetRFC822Message::operator<< (rStrm); + + for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++) + rStrm << m_nIndex[i]; + +#ifdef ENABLE_BYTESTRING_STREAM_OPERATORS + rStrm << m_aBoundary; +#else + rStrm.WriteByteString (m_aBoundary); +#endif + rStrm << nNumChildren; + + return rStrm; +} + +/* + * operator>> + */ +SvStream& INetMIMEMessage::operator>> (SvStream& rStrm) +{ + INetRFC822Message::operator>> (rStrm); + + for (USHORT i = 0; i < INETMSG_MIME_NUMHDR; i++) + rStrm >> m_nIndex[i]; + +#ifdef ENABLE_BYTESTRING_STREAM_OPERATORS + rStrm >> m_aBoundary; +#else + rStrm.ReadByteString (m_aBoundary); +#endif + rStrm >> nNumChildren; + + return rStrm; +} + +/*======================================================================= + * + * INetNewsMessage Implementation. + * + *=====================================================================*/ +/* + * _ImplINetNewsMessageHeaderData. + */ +static const ByteString _ImplINetNewsMessageHeaderData[] = +{ + ByteString ("Approved"), + ByteString ("Control"), + ByteString ("Distribution"), + ByteString ("Expires"), + ByteString ("Followup-To"), + ByteString ("Lines"), + ByteString ("Newsgroups"), + ByteString ("Organization"), + ByteString ("Path"), + ByteString ("Summary"), + ByteString ("Xref"), + ByteString ("X-Newsreader") +}; + +#define NEWSHDR(n) _ImplINetNewsMessageHeaderData[(n)] + +/* + * _ImplINetNewsMessageHeaderState. + */ +enum _ImplINetNewsMessageHeaderState +{ + INETMSG_NEWS_BEGIN, + INETMSG_NEWS_CHECK, + INETMSG_NEWS_OK, + INETMSG_NEWS_JUNK, + + INETMSG_NEWS_LETTER_X +}; + +/* + * INetNewsMessage. + */ +INetNewsMessage::INetNewsMessage (void) + : INetMIMEMessage () +{ + for (USHORT i = 0; i < INETMSG_NEWS_NUMHDR; i++) + m_nIndex[i] = LIST_ENTRY_NOTFOUND; +} + +INetNewsMessage::INetNewsMessage (const INetNewsMessage& rMsg) + : INetMIMEMessage (rMsg) +{ + for (USHORT i = 0; i < INETMSG_NEWS_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; +} + +/* + * operator= + */ +INetNewsMessage& INetNewsMessage::operator= (const INetNewsMessage& rMsg) +{ + if (this != &rMsg) + { + // Assign base. + INetMIMEMessage::operator= (rMsg); + + // Cleanup and copy. + for (USHORT i = 0; i < INETMSG_NEWS_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; + } + return *this; +} + +/* + * ~INetNewsMessage. + */ +INetNewsMessage::~INetNewsMessage (void) +{ +} + +/* + * CreateMessage. + */ +INetNewsMessage *INetNewsMessage::CreateMessage ( + const INetNewsMessage& rMsg) const +{ + return (new INetNewsMessage (rMsg)); +} + +/* + * SetHeaderField. + * (Header Field Parser). + */ +ULONG INetNewsMessage::SetHeaderField ( + const INetMessageHeader &rHeader, ULONG nNewIndex) +{ + ByteString aName (rHeader.GetName()); + const sal_Char *pData = aName.GetBuffer(); + const sal_Char *pStop = pData + aName.Len() + 1; + const sal_Char *check = ""; + + ULONG nIdx = LIST_APPEND; + int eState = INETMSG_NEWS_BEGIN; + int eOkState = INETMSG_NEWS_OK; + + while (pData < pStop) + { + switch (eState) + { + case INETMSG_NEWS_BEGIN: + eState = INETMSG_NEWS_CHECK; + eOkState = INETMSG_NEWS_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'a': + check = "pproved"; + nIdx = INETMSG_NEWS_APPROVED; + break; + + case 'c': + check = "ontrol"; + nIdx = INETMSG_NEWS_CONTROL; + break; + + case 'd': + check = "istribution"; + nIdx = INETMSG_NEWS_DISTRIBUTION; + break; + + case 'e': + check = "xpires"; + nIdx = INETMSG_NEWS_EXPIRES; + break; + + case 'f': + check = "ollowup-to"; + nIdx = INETMSG_NEWS_FOLLOWUP_TO; + break; + + case 'l': + check = "ines"; + nIdx = INETMSG_NEWS_LINES; + break; + + case 'n': + check = "ewsgroups"; + nIdx = INETMSG_NEWS_NEWSGROUPS; + break; + + case 'o': + check = "rganization"; + nIdx = INETMSG_NEWS_ORGANIZATION; + break; + + case 'p': + check = "ath"; + nIdx = INETMSG_NEWS_PATH; + break; + + case 's': + check = "ummary"; + nIdx = INETMSG_NEWS_SUMMARY; + break; + + case 'x': + eState = INETMSG_NEWS_LETTER_X; + break; + + default: + eState = INETMSG_NEWS_JUNK; + break; + } + pData++; + break; + + case INETMSG_NEWS_LETTER_X: + eState = INETMSG_NEWS_CHECK; + eOkState = INETMSG_NEWS_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'r': + check = "ef"; + nIdx = INETMSG_NEWS_XREF; + break; + + case '-': + check = "newsreader"; + nIdx = INETMSG_NEWS_X_NEWSREADER; + break; + + default: + eState = INETMSG_NEWS_JUNK; + break; + } + pData++; + break; + + case INETMSG_NEWS_CHECK: + if (*check) + { + while (*pData && *check && + (rtl_char_toLowerCase (*pData) == *check)) + { + pData++; + check++; + } + } + else + { + check = pData; + } + eState = (*check == '\0') ? eOkState : INETMSG_NEWS_JUNK; + break; + + case INETMSG_NEWS_OK: + pData = pStop; + SetHeaderField_Impl ( + HEADERFIELD (NEWSHDR(nIdx), rHeader.GetValue()), + m_nIndex[nIdx]); + nNewIndex = m_nIndex[nIdx]; + break; + + default: // INETMSG_NEWS_JUNK + pData = pStop; + nNewIndex = INetMIMEMessage::SetHeaderField ( + rHeader, nNewIndex); + break; + } + } + return nNewIndex; +} + +/* + * Specific Set-Methods. + */ +void INetNewsMessage::SetApproved (const String& rApproved) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_APPROVED), rApproved, + m_nIndex[INETMSG_NEWS_APPROVED]); +} + +void INetNewsMessage::SetControl (const String& rControl) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_CONTROL), rControl, + m_nIndex[INETMSG_NEWS_CONTROL]); +} + +void INetNewsMessage::SetDistribution (const String& rDistribution) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_DISTRIBUTION), rDistribution, + m_nIndex[INETMSG_NEWS_DISTRIBUTION]); +} + +void INetNewsMessage::SetExpires (const String& rExpires) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_EXPIRES), rExpires, + m_nIndex[INETMSG_NEWS_EXPIRES]); +} + +void INetNewsMessage::SetFollowupTo (const String& rFollowupTo) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_FOLLOWUP_TO), rFollowupTo, + m_nIndex[INETMSG_NEWS_FOLLOWUP_TO]); +} + +void INetNewsMessage::SetLines (const String& rLines) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_LINES), rLines, + m_nIndex[INETMSG_NEWS_LINES]); +} + +void INetNewsMessage::SetNewsgroups (const String& rNewsgroups) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_NEWSGROUPS), rNewsgroups, + m_nIndex[INETMSG_NEWS_NEWSGROUPS]); +} + +void INetNewsMessage::SetOrganization (const String& rOrganization) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_ORGANIZATION), rOrganization, + m_nIndex[INETMSG_NEWS_ORGANIZATION]); +} + +void INetNewsMessage::SetPath (const String& rPath) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_PATH), rPath, + m_nIndex[INETMSG_NEWS_PATH]); +} + +void INetNewsMessage::SetSummary (const String& rSummary) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_SUMMARY), rSummary, + m_nIndex[INETMSG_NEWS_SUMMARY]); +} + +void INetNewsMessage::SetXref (const String& rXref) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_XREF), rXref, + m_nIndex[INETMSG_NEWS_XREF]); +} + +void INetNewsMessage::SetXNewsreader (const String& rXNewsreader) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + NEWSHDR(INETMSG_NEWS_X_NEWSREADER), rXNewsreader, + m_nIndex[INETMSG_NEWS_X_NEWSREADER]); +} + +/* + * operator<< + */ +SvStream& INetNewsMessage::operator<< (SvStream& rStrm) const +{ + INetMIMEMessage::operator<< (rStrm); + + for (USHORT i = 0; i < INETMSG_NEWS_NUMHDR; i++) + rStrm << m_nIndex[i]; + + return rStrm; +} + +/* + * operator>> + */ +SvStream& INetNewsMessage::operator>> (SvStream& rStrm) +{ + INetMIMEMessage::operator>> (rStrm); + + for (USHORT i = 0; i < INETMSG_NEWS_NUMHDR; i++) + rStrm >> m_nIndex[i]; + + return rStrm; +} + +/*======================================================================= + * + * INetHTTPMessage Implementation. + * + *=====================================================================*/ +/* + * _ImplINetHTTPMessageHeaderData. + */ +static const ByteString _ImplINetHTTPMessageHeaderData[] = +{ + ByteString ("Accept"), + ByteString ("Accept-Charset"), + ByteString ("Accept-Encoding"), + ByteString ("Accept-Language"), + ByteString ("Allow"), + ByteString ("Authorization"), + ByteString ("Cache-Control"), + ByteString ("Connection"), + ByteString ("Content-Encoding"), + ByteString ("Content-Language"), + ByteString ("Content-Length"), + ByteString ("Content-MD5"), + ByteString ("Content-Range"), + ByteString ("Content-Version"), + ByteString ("Cookie"), + ByteString ("Derived-From"), + ByteString ("Expires"), + ByteString ("Forwarded"), + ByteString ("Host"), + ByteString ("If-Modified-Since"), + ByteString ("Keep-Alive"), + ByteString ("Last-Modified"), + ByteString ("Link"), + ByteString ("Location"), + ByteString ("Proxy-Authenticate"), + ByteString ("Proxy-Authorization"), + ByteString ("Pragma"), + ByteString ("Public"), + ByteString ("Range"), + ByteString ("Referer"), + ByteString ("Retry-After"), + ByteString ("Server"), + ByteString ("Title"), + ByteString ("Transfer-Encoding"), + ByteString ("Unless"), + ByteString ("Upgrade"), + ByteString ("URI"), + ByteString ("User-Agent"), + ByteString ("WWW-Authenticate") +}; + +#define HTTPHDR(n) _ImplINetHTTPMessageHeaderData[(n)] + +/* + * _ImplINetHTTPMessageHeaderState. + */ +enum _ImplINetHTTPMessageHeaderState +{ + INETMSG_HTTP_BEGIN, + INETMSG_HTTP_CHECK, + INETMSG_HTTP_OK, + INETMSG_HTTP_JUNK, + + INETMSG_HTTP_LETTER_A, + INETMSG_HTTP_LETTER_C, + INETMSG_HTTP_LETTER_L, + INETMSG_HTTP_LETTER_P, + INETMSG_HTTP_LETTER_R, + INETMSG_HTTP_LETTER_T, + INETMSG_HTTP_LETTER_U, + INETMSG_HTTP_TOKEN_CON, + INETMSG_HTTP_CONTENT, + INETMSG_HTTP_PROXY_AUTH +}; + +/* + * INetHTTPMessage. + */ +INetHTTPMessage::INetHTTPMessage (void) + : INetMIMEMessage () +{ + for (USHORT i = 0; i < INETMSG_HTTP_NUMHDR; i++) + m_nIndex[i] = LIST_ENTRY_NOTFOUND; +} + +INetHTTPMessage::INetHTTPMessage (const INetHTTPMessage& rMsg) + : INetMIMEMessage (rMsg) +{ + for (USHORT i = 0; i < INETMSG_HTTP_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; +} + +/* + * operator= + */ +INetHTTPMessage& INetHTTPMessage::operator= (const INetHTTPMessage& rMsg) +{ + if (this != &rMsg) + { + // Assign base. + INetMIMEMessage::operator= (rMsg); + + // Cleanup and copy. + for (USHORT i = 0; i < INETMSG_HTTP_NUMHDR; i++) + m_nIndex[i] = rMsg.m_nIndex[i]; + } + return *this; +} + +/* + * ~INetHTTPMessage. + */ +INetHTTPMessage::~INetHTTPMessage (void) +{ +} + +/* + * CreateMessage. + */ +INetHTTPMessage *INetHTTPMessage::CreateMessage ( + const INetHTTPMessage& rMsg) const +{ + return (new INetHTTPMessage (rMsg)); +} + +/* + * SetHeaderField. + * (Header Field Parser). + */ +ULONG INetHTTPMessage::SetHeaderField ( + const INetMessageHeader &rHeader, ULONG nNewIndex) +{ + ByteString aName (rHeader.GetName()); + const sal_Char *pData = aName.GetBuffer(); + const sal_Char *pStop = pData + aName.Len() + 1; + const sal_Char *check = ""; + + ULONG nIdx = LIST_APPEND; + int eState = INETMSG_HTTP_BEGIN; + int eOkState = INETMSG_HTTP_OK; + + while (pData < pStop) + { + switch (eState) + { + case INETMSG_HTTP_BEGIN: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'a': + eState = INETMSG_HTTP_LETTER_A; + break; + + case 'c': + eState = INETMSG_HTTP_LETTER_C; + break; + + case 'd': + check = "erived-from"; + nIdx = INETMSG_HTTP_DERIVED_FROM; + break; + + case 'e': + check = "xpires"; + nIdx = INETMSG_HTTP_EXPIRES; + break; + + case 'f': + check = "orwarded"; + nIdx = INETMSG_HTTP_FORWARDED; + break; + + case 'h': + check = "ost"; + nIdx = INETMSG_HTTP_HOST; + break; + + case 'i': + check = "f-modified-since"; + nIdx = INETMSG_HTTP_IF_MODIFIED_SINCE; + break; + + case 'k': + check = "eep-alive"; + nIdx = INETMSG_HTTP_KEEP_ALIVE; + break; + + case 'l': + eState = INETMSG_HTTP_LETTER_L; + break; + + case 'p': + eState = INETMSG_HTTP_LETTER_P; + break; + + case 'r': + eState = INETMSG_HTTP_LETTER_R; + break; + + case 's': + check = "erver"; + nIdx = INETMSG_HTTP_SERVER; + break; + + case 't': + eState = INETMSG_HTTP_LETTER_T; + break; + + case 'u': + eState = INETMSG_HTTP_LETTER_U; + break; + + case 'w': + check = "ww-authenticate"; + nIdx = INETMSG_HTTP_WWW_AUTHENTICATE; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_A: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'c': + if (INetMIME::equalIgnoreCase ( + pData, pData + 14, "ccept-language")) + { + nIdx = INETMSG_HTTP_ACCEPT_LANGUAGE; + pData += 14; + } + else if (INetMIME::equalIgnoreCase ( + pData, pData + 14, "ccept-encoding")) + { + nIdx = INETMSG_HTTP_ACCEPT_ENCODING; + pData += 14; + } + else if (INetMIME::equalIgnoreCase ( + pData, pData + 13, "ccept-charset")) + { + nIdx = INETMSG_HTTP_ACCEPT_CHARSET; + pData += 13; + } + else if (INetMIME::equalIgnoreCase ( + pData, pData + 5, "ccept")) + { + nIdx = INETMSG_HTTP_ACCEPT; + pData += 5; + } + else + { + eState = INETMSG_HTTP_JUNK; + } + break; + + case 'l': + check = "low"; + nIdx = INETMSG_HTTP_ALLOW; + break; + + case 'u': + check = "thorization"; + nIdx = INETMSG_HTTP_AUTHORIZATION; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_C: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'a': + check = "che-control"; + nIdx = INETMSG_HTTP_CACHE_CONTROL; + break; + + case 'o': + if (rtl_char_toLowerCase (*(pData + 1)) == 'n') + { + eState = INETMSG_HTTP_TOKEN_CON; + } + else if (rtl_char_toLowerCase (*(pData + 1)) == 'o') + { + check = "kie"; + nIdx = INETMSG_HTTP_COOKIE; + } + else + { + eState = INETMSG_HTTP_JUNK; + } + pData++; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_L: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'a': + check = "st-modified"; + nIdx = INETMSG_HTTP_LAST_MODIFIED; + break; + + case 'i': + check = "nk"; + nIdx = INETMSG_HTTP_LINK; + break; + + case 'o': + check = "cation"; + nIdx = INETMSG_HTTP_LOCATION; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_P: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'r': + switch (rtl_char_toLowerCase (*(pData + 1))) + { + case 'a': + check = "gma"; + nIdx = INETMSG_HTTP_PRAGMA; + break; + + case 'o': + check = "xy-auth"; + eOkState = INETMSG_HTTP_PROXY_AUTH; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case 'u': + check = "blic"; + nIdx = INETMSG_HTTP_PUBLIC; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_R: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'a': + check = "nge"; + nIdx = INETMSG_HTTP_RANGE; + break; + + case 'e': + switch (rtl_char_toLowerCase (*(pData + 1))) + { + case 'f': + check = "erer"; + nIdx = INETMSG_HTTP_REFERER; + break; + + case 't': + check = "ry-after"; + nIdx = INETMSG_HTTP_RETRY_AFTER; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_T: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'i': + check = "tle"; + nIdx = INETMSG_HTTP_TITLE; + break; + + case 'r': + check = "ansfer-encoding"; + nIdx = INETMSG_HTTP_TRANSFER_ENCODING; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_LETTER_U: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'n': + check = "less"; + nIdx = INETMSG_HTTP_UNLESS; + break; + + case 'p': + check = "grade"; + nIdx = INETMSG_HTTP_UPGRADE; + break; + + case 'r': + check = "i"; + nIdx = INETMSG_HTTP_URI; + break; + + case 's': + check = "er-agent"; + nIdx = INETMSG_HTTP_USER_AGENT; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_TOKEN_CON: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'n': + check = "ection"; + nIdx = INETMSG_HTTP_CONNECTION; + break; + + case 't': + check = "ent-"; + eOkState = INETMSG_HTTP_CONTENT; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_CONTENT: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'e': + check = "ncoding"; + nIdx = INETMSG_HTTP_CONTENT_ENCODING; + break; + + case 'l': + switch (rtl_char_toLowerCase (*(pData + 1))) + { + case 'a': + check = "nguage"; + nIdx = INETMSG_HTTP_CONTENT_LANGUAGE; + break; + + case 'e': + check = "ngth"; + nIdx = INETMSG_HTTP_CONTENT_LENGTH; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case 'm': + check = "d5"; + nIdx = INETMSG_HTTP_CONTENT_MD5; + break; + + case 'r': + check = "ange"; + nIdx = INETMSG_HTTP_CONTENT_RANGE; + break; + + case 'v': + check = "ersion"; + nIdx = INETMSG_HTTP_CONTENT_VERSION; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_PROXY_AUTH: + eState = INETMSG_HTTP_CHECK; + eOkState = INETMSG_HTTP_OK; + + switch (rtl_char_toLowerCase (*pData)) + { + case 'e': + check = "nticate"; + nIdx = INETMSG_HTTP_PROXY_AUTHENTICATE; + break; + + case 'o': + check = "rization"; + nIdx = INETMSG_HTTP_PROXY_AUTHORIZATION; + break; + + default: + eState = INETMSG_HTTP_JUNK; + break; + } + pData++; + break; + + case INETMSG_HTTP_CHECK: + if (*check) + { + while (*pData && *check && + (rtl_char_toLowerCase (*pData) == *check)) + { + pData++; + check++; + } + } + else + { + check = pData; + } + eState = (*check == '\0') ? eOkState : INETMSG_HTTP_JUNK; + break; + + case INETMSG_HTTP_OK: + pData = pStop; + SetHeaderField_Impl ( + HEADERFIELD (HTTPHDR(nIdx), rHeader.GetValue()), + m_nIndex[nIdx]); + nNewIndex = m_nIndex[nIdx]; + break; + + default: // INETMSG_HTTP_JUNK + pData = pStop; + nNewIndex = INetMIMEMessage::SetHeaderField ( + rHeader, nNewIndex); + break; + } + } + return nNewIndex; +} + +/* + * Specific Set-Methods. + */ +void INetHTTPMessage::SetAccept (const String& rAccept) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_ACCEPT), rAccept, + m_nIndex[INETMSG_HTTP_ACCEPT]); +} + +void INetHTTPMessage::SetAcceptCharset (const String& rAcceptCharset) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_ACCEPT_CHARSET), rAcceptCharset, + m_nIndex[INETMSG_HTTP_ACCEPT_CHARSET]); +} + +void INetHTTPMessage::SetAcceptEncoding (const String& rAcceptEncoding) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_ACCEPT_ENCODING), rAcceptEncoding, + m_nIndex[INETMSG_HTTP_ACCEPT_ENCODING]); +} + +void INetHTTPMessage::SetAcceptLanguage (const String& rAcceptLanguage) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_ACCEPT_LANGUAGE), rAcceptLanguage, + m_nIndex[INETMSG_HTTP_ACCEPT_LANGUAGE]); +} + +void INetHTTPMessage::SetAllow (const String& rAllow) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_ALLOW), rAllow, + m_nIndex[INETMSG_HTTP_ALLOW]); +} + +void INetHTTPMessage::SetAuthorization (const String& rAuthorization) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_AUTHORIZATION), rAuthorization, + m_nIndex[INETMSG_HTTP_AUTHORIZATION]); +} + +void INetHTTPMessage::SetCacheControl (const String& rCacheControl) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CACHE_CONTROL), rCacheControl, + m_nIndex[INETMSG_HTTP_CACHE_CONTROL]); +} + +void INetHTTPMessage::SetConnection (const String& rConnection) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONNECTION), rConnection, + m_nIndex[INETMSG_HTTP_CONNECTION]); +} + +void INetHTTPMessage::SetContentEncoding (const String& rContentEncoding) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_ENCODING), rContentEncoding, + m_nIndex[INETMSG_HTTP_CONTENT_ENCODING]); +} + +void INetHTTPMessage::SetContentLanguage (const String& rContentLanguage) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_LANGUAGE), rContentLanguage, + m_nIndex[INETMSG_HTTP_CONTENT_LANGUAGE]); +} + +void INetHTTPMessage::SetContentLength (const String& rContentLength) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_LENGTH), rContentLength, + m_nIndex[INETMSG_HTTP_CONTENT_LENGTH]); +} + +void INetHTTPMessage::SetContentMD5 (const String& rContentMD5) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_MD5), rContentMD5, + m_nIndex[INETMSG_HTTP_CONTENT_MD5]); +} + +void INetHTTPMessage::SetContentRange (const String& rContentRange) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_RANGE), rContentRange, + m_nIndex[INETMSG_HTTP_CONTENT_RANGE]); +} + +void INetHTTPMessage::SetContentVersion (const String& rContentVersion) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_CONTENT_VERSION), rContentVersion, + m_nIndex[INETMSG_HTTP_CONTENT_VERSION]); +} + +void INetHTTPMessage::SetCookie (const String& rCookie) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_COOKIE), rCookie, + m_nIndex[INETMSG_HTTP_COOKIE]); +} + +void INetHTTPMessage::SetDerivedFrom (const String& rDerivedFrom) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_DERIVED_FROM), rDerivedFrom, + m_nIndex[INETMSG_HTTP_DERIVED_FROM]); +} + +void INetHTTPMessage::SetExpires (const String& rExpires) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_EXPIRES), rExpires, + m_nIndex[INETMSG_HTTP_EXPIRES]); +} + +void INetHTTPMessage::SetForwarded (const String& rForwarded) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_FORWARDED), rForwarded, + m_nIndex[INETMSG_HTTP_FORWARDED]); +} + +void INetHTTPMessage::SetHost (const String& rHost) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_HOST), rHost, + m_nIndex[INETMSG_HTTP_HOST]); +} + +void INetHTTPMessage::SetIfModifiedSince (const String& rIfModifiedSince) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_IF_MODIFIED_SINCE), rIfModifiedSince, + m_nIndex[INETMSG_HTTP_IF_MODIFIED_SINCE]); +} + +void INetHTTPMessage::SetKeepAlive (const String& rKeepAlive) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_KEEP_ALIVE), rKeepAlive, + m_nIndex[INETMSG_HTTP_KEEP_ALIVE]); +} + +void INetHTTPMessage::SetLastModified (const String& rLastModified) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_LAST_MODIFIED), rLastModified, + m_nIndex[INETMSG_HTTP_LAST_MODIFIED]); +} + +void INetHTTPMessage::SetLink (const String& rLink) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_LINK), rLink, + m_nIndex[INETMSG_HTTP_LINK]); +} + +void INetHTTPMessage::SetLocation (const String& rLocation) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_LOCATION), rLocation, + m_nIndex[INETMSG_HTTP_LOCATION]); +} + +void INetHTTPMessage::SetProxyAuthenticate ( + const String& rProxyAuthenticate) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_PROXY_AUTHENTICATE), rProxyAuthenticate, + m_nIndex[INETMSG_HTTP_PROXY_AUTHENTICATE]); +} + +void INetHTTPMessage::SetProxyAuthorization ( + const String& rProxyAuthorization) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_PROXY_AUTHORIZATION), rProxyAuthorization, + m_nIndex[INETMSG_HTTP_PROXY_AUTHORIZATION]); +} + +void INetHTTPMessage::SetPragma (const String& rPragma) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_PRAGMA), rPragma, + m_nIndex[INETMSG_HTTP_PRAGMA]); +} + +void INetHTTPMessage::SetPublic (const String& rPublic) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_PUBLIC), rPublic, + m_nIndex[INETMSG_HTTP_PUBLIC]); +} + +void INetHTTPMessage::SetRange (const String& rRange) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_RANGE), rRange, + m_nIndex[INETMSG_HTTP_RANGE]); +} + +void INetHTTPMessage::SetReferer (const String& rReferer) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_REFERER), rReferer, + m_nIndex[INETMSG_HTTP_REFERER]); +} + +void INetHTTPMessage::SetRetryAfter (const String& rRetryAfter) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_RETRY_AFTER), rRetryAfter, + m_nIndex[INETMSG_HTTP_RETRY_AFTER]); +} + +void INetHTTPMessage::SetServer (const String& rServer) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_SERVER), rServer, + m_nIndex[INETMSG_HTTP_SERVER]); +} + +void INetHTTPMessage::SetTitle (const String& rTitle) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_TITLE), rTitle, + m_nIndex[INETMSG_HTTP_TITLE]); +} + +void INetHTTPMessage::SetTransferEncoding ( + const String& rTransferEncoding) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_TRANSFER_ENCODING), rTransferEncoding, + m_nIndex[INETMSG_HTTP_TRANSFER_ENCODING]); +} + +void INetHTTPMessage::SetUnless (const String& rUnless) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_UNLESS), rUnless, + m_nIndex[INETMSG_HTTP_UNLESS]); +} + +void INetHTTPMessage::SetUpgrade (const String& rUpgrade) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_UPGRADE), rUpgrade, + m_nIndex[INETMSG_HTTP_UPGRADE]); +} + +void INetHTTPMessage::SetURI (const String& rURI) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_URI), rURI, + m_nIndex[INETMSG_HTTP_URI]); +} + +void INetHTTPMessage::SetUserAgent (const String& rUserAgent) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_USER_AGENT), rUserAgent, + m_nIndex[INETMSG_HTTP_USER_AGENT]); +} + +void INetHTTPMessage::SetWWWAuthenticate (const String& rWWWAuthenticate) +{ + SetHeaderField_Impl ( + INetMIME::HEADER_FIELD_TEXT, + HTTPHDR(INETMSG_HTTP_WWW_AUTHENTICATE), rWWWAuthenticate, + m_nIndex[INETMSG_HTTP_WWW_AUTHENTICATE]); +} + +/* + * operator<< + */ +SvStream& INetHTTPMessage::operator<< (SvStream& rStrm) const +{ + INetMIMEMessage::operator<< (rStrm); + + for (USHORT i = 0; i < INETMSG_HTTP_NUMHDR; i++) + rStrm << m_nIndex[i]; + + return rStrm; +} + +/* + * operator>> + */ +SvStream& INetHTTPMessage::operator>> (SvStream& rStrm) +{ + INetMIMEMessage::operator>> (rStrm); + + for (USHORT i = 0; i < INETMSG_HTTP_NUMHDR; i++) + rStrm >> m_nIndex[i]; + + return rStrm; +} + diff --git a/tools/source/inet/inetstrm.cxx b/tools/source/inet/inetstrm.cxx new file mode 100644 index 000000000000..04072d617642 --- /dev/null +++ b/tools/source/inet/inetstrm.cxx @@ -0,0 +1,2059 @@ +/************************************************************************* + * + * $RCSfile: inetstrm.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _SAL_TYPES_H_ +#include <sal/types.h> +#endif + +#ifndef _RTL_CHAR_H_ +#include <rtl/char.h> +#endif +#ifndef _RTL_MEMORY_H_ +#include <rtl/memory.h> +#endif + +#ifndef _CACHESTR_HXX +#include <cachestr.hxx> +#endif +#ifndef _TOOLS_DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _TOOLS_INETMSG_HXX +#include <inetmsg.hxx> +#endif +#ifndef _TOOLS_INETSTRM_HXX +#include <inetstrm.hxx> +#endif +#ifndef _ZCODEC_HXX +#include <zcodec.hxx> +#endif + +#include <ctype.h> // toupper + +#define CONSTASCII_STRINGPARAM(a) (a), RTL_TEXTENCODING_ASCII_US + +/*======================================================================= + * + * INetMessageEncodeQPStream Interface. + * (Quoted-Printable Encoding) + * + *=====================================================================*/ +class INetMessageEncodeQPStream_Impl : public INetMessageIStream +{ + SvStream *pMsgStrm; + + ULONG nMsgBufSiz; + sal_Char *pMsgBuffer; + sal_Char *pMsgRead; + sal_Char *pMsgWrite; + + ULONG nTokBufSiz; + sal_Char *pTokBuffer; + sal_Char *pTokRead; + sal_Char *pTokWrite; + + INetMessageStreamState eState; + BOOL bDone; + + virtual int GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx = NULL); + +public: + INetMessageEncodeQPStream_Impl (ULONG nMsgBufferSize = 1024); + virtual ~INetMessageEncodeQPStream_Impl (void); +}; + +/*===================================================================== + * + * INetMessageDecodeQPStream Interface. + * (Quoted-Printable Decoding) + * + *====================================================================*/ +class INetMessageDecodeQPStream_Impl : public INetMessageOStream +{ + INetMessageStreamState eState; + SvMemoryStream *pMsgBuffer; + + ULONG nTokBufLen; + sal_Char pTokBuffer[4]; + + virtual int PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx = NULL); + +public: + INetMessageDecodeQPStream_Impl (void); + virtual ~INetMessageDecodeQPStream_Impl (void); +}; + +/*====================================================================== + * + * INetMessageEncode64Stream Interface. + * (Base64 Encoding) + * + *====================================================================*/ +class INetMessageEncode64Stream_Impl : public INetMessageIStream +{ + SvStream *pMsgStrm; + + ULONG nMsgBufSiz; + sal_uInt8 *pMsgBuffer; + sal_uInt8 *pMsgRead; + sal_uInt8 *pMsgWrite; + + ULONG nTokBufSiz; + sal_Char *pTokBuffer; + sal_Char *pTokRead; + sal_Char *pTokWrite; + + BOOL bDone; + + virtual int GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx = NULL); + +public: + INetMessageEncode64Stream_Impl (ULONG nMsgBufferSize = 2048); + virtual ~INetMessageEncode64Stream_Impl (void); +}; + +/*====================================================================== + * + * INetMessageDecode64Stream Interface. + * (Base64 Decoding) + * + *====================================================================*/ +class INetMessageDecode64Stream_Impl : public INetMessageOStream +{ + INetMessageStreamState eState; + + ULONG nMsgBufSiz; + sal_Char *pMsgBuffer; + sal_Char *pMsgRead; + sal_Char *pMsgWrite; + + virtual int PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx = NULL); + +public: + INetMessageDecode64Stream_Impl (ULONG nMsgBufferSize = 128); + virtual ~INetMessageDecode64Stream_Impl (void); +}; + +/*========================================================================= + * + * INetIStream Implementation. + * + *=======================================================================*/ +/* + * INetIStream. + */ +INetIStream::INetIStream (ULONG nIBufferSize) +{ +} + +/* + * ~INetIStream. + */ +INetIStream::~INetIStream (void) +{ +} + +/* + * Read. + */ +int INetIStream::Read (sal_Char *pData, ULONG nSize, void *pCtx) +{ + return GetData (pData, nSize, pCtx); +} + +/* + * Decode64. + */ +void INetIStream::Decode64 (SvStream& rIn, SvStream& rOut) +{ + INetMessage aMsg; + aMsg.SetDocumentLB(new SvAsyncLockBytes(&rOut, FALSE)); + + INetMessageDecode64Stream_Impl aStream (8192); + aStream.SetTargetMessage (&aMsg); + + sal_Char* pBuf = new sal_Char[8192]; + + int nRead = 0; + while ((nRead = rIn.Read (pBuf, 8192)) > 0) + aStream.Write( pBuf, nRead ); + aStream.Write ("\r\n", 2); + + delete[] pBuf; +} + +/* + * Encode64. + */ +void INetIStream::Encode64 (SvStream& rIn, SvStream& rOut) +{ + INetMessage aMsg; + aMsg.SetDocumentLB ( + new SvLockBytes (&rIn, FALSE)); + + INetMessageEncode64Stream_Impl aStream (8192); + aStream.SetSourceMessage (&aMsg); + + sal_Char* pBuf = new sal_Char[8192]; + + int nRead = 0; + while ((nRead = aStream.Read (pBuf, 8192)) > 0) + rOut.Write( pBuf, nRead ); + + delete[] pBuf; +} + +/*========================================================================= + * + * INetOStream Implementation. + * + *=======================================================================*/ +/* + * INetOStream. + */ +INetOStream::INetOStream (ULONG nOBufferSize) +{ +} + +/* + * ~INetOStream. + */ +INetOStream::~INetOStream (void) +{ +} + +/* + * Write. + */ +int INetOStream::Write (const sal_Char *pData, ULONG nSize, void *pCtx) +{ + return PutData (pData, nSize, pCtx); +} + +/*========================================================================= + * + * INetMessageIStream Implementation. + * + *=======================================================================*/ +/* + * INetMessageIStream. + */ +INetMessageIStream::INetMessageIStream (ULONG nBufferSize) + : INetIStream (0), + pSourceMsg (NULL), + bHeaderGenerated (FALSE), + nBufSiz (nBufferSize), + pMsgStrm (NULL), + pMsgBuffer (new SvMemoryStream) +{ + pMsgBuffer->SetStreamCharSet (RTL_TEXTENCODING_ASCII_US); + pBuffer = new sal_Char[nBufSiz]; + pRead = pWrite = pBuffer; +} + +/* + * ~INetMessageIStream. + */ +INetMessageIStream::~INetMessageIStream (void) +{ + delete [] pBuffer; + delete pMsgBuffer; + delete pMsgStrm; +} + +/* + * GetData. + */ +int INetMessageIStream::GetData (sal_Char *pData, ULONG nSize, void *pCtx) +{ + if (pSourceMsg == NULL) return INETSTREAM_STATUS_ERROR; + + sal_Char *pWBuf = pData; + sal_Char *pWEnd = pData + nSize; + + while (pWBuf < pWEnd) + { + // Caller's buffer not yet filled. + ULONG n = pRead - pWrite; + if (n > 0) + { + // Bytes still in buffer. + ULONG m = pWEnd - pWBuf; + if (m < n) n = m; + for (ULONG i = 0; i < n; i++) *pWBuf++ = *pWrite++; + } + else + { + // Buffer empty. Reset to <Begin-of-Buffer>. + pRead = pWrite = pBuffer; + + // Read next message line. + int nRead = GetMsgLine (pBuffer, nBufSiz, pCtx); + if (nRead > 0) + { + // Set read pointer. + pRead = pBuffer + nRead; + } + else + { + if (!bHeaderGenerated) + { + // Header generated. Insert empty line. + bHeaderGenerated = TRUE; + *pRead++ = '\r'; + *pRead++ = '\n'; + } + else + { + // Body generated. + return (pWBuf - pData); + } + } + } + } + return (pWBuf - pData); +} + +/* + * GetMsgLine. + */ +int INetMessageIStream::GetMsgLine (sal_Char *pData, ULONG nSize, void *pCtx) +{ + if (pSourceMsg == NULL) return INETSTREAM_STATUS_ERROR; + + sal_Char *pWBuf = pData; + sal_Char *pWEnd = pData + nSize; + + if (!bHeaderGenerated) + { + ULONG i, n; + + if (pMsgBuffer->Tell() == 0) + { + // Insert formatted header into buffer. + n = pSourceMsg->GetHeaderCount(); + for (i = 0; i < n; i++) + { + INetMessageHeader aHeader (pSourceMsg->GetHeaderField(i)); + if (aHeader.GetValue().Len()) + { + // NYI: Folding long lines. + *pMsgBuffer << (sal_Char*)(aHeader.GetName().GetBuffer()); + *pMsgBuffer << ": "; + *pMsgBuffer << (sal_Char*)(aHeader.GetValue().GetBuffer()); + *pMsgBuffer << "\r\n"; + } + } + + pMsgWrite = (sal_Char *)(pMsgBuffer->GetData()); + pMsgRead = pMsgWrite + pMsgBuffer->Tell(); + } + + n = pMsgRead - pMsgWrite; + if (n > 0) + { + // Move to caller. + if (nSize < n) n = nSize; + for (i = 0; i < n; i++) *pWBuf++ = *pMsgWrite++; + } + else + { + // Reset buffer. + pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN); + } + } + else + { + if (pSourceMsg->GetDocumentLB()) + { + if (pMsgStrm == NULL) + pMsgStrm = new SvStream (pSourceMsg->GetDocumentLB()); + + ULONG nRead = pMsgStrm->Read (pWBuf, (pWEnd - pWBuf)); + pWBuf += nRead; + } + } + return (pWBuf - pData); +} + +/*========================================================================= + * + * INetMessageOStream Implementation. + * + *=======================================================================*/ +/* + * INetMessageOStream. + */ +INetMessageOStream::INetMessageOStream (void) + : INetOStream (0), + pTargetMsg (NULL), + bHeaderParsed (FALSE), + eOState (INETMSG_EOL_BEGIN), + pMsgBuffer (new SvMemoryStream) +{ +} + +/* + * ~INetMessageOStream. + */ +INetMessageOStream::~INetMessageOStream (void) +{ + if (pMsgBuffer->Tell() > 0) + PutMsgLine ((const sal_Char *) pMsgBuffer->GetData(), pMsgBuffer->Tell()); + delete pMsgBuffer; + + if (pTargetMsg) + { + SvOpenLockBytes *pLB = + PTR_CAST (SvOpenLockBytes, pTargetMsg->GetDocumentLB()); + if (pLB) + { + pLB->Flush(); + pLB->Terminate(); + } + } +} + +/* + * PutData. + * (Simple Field Parsing (RFC822, Appendix B)). + */ +int INetMessageOStream::PutData ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + if (pTargetMsg == NULL) return INETSTREAM_STATUS_ERROR; + + const sal_Char *pStop = (pData + nSize); + + while (!bHeaderParsed && (pData < pStop)) + { + if (eOState == INETMSG_EOL_BEGIN) + { + if ((*pData == '\r') || (*pData == '\n')) + { + /* + * Empty Line. Separates header fields from message body. + * Skip this and any 2nd line break character (if any). + */ + pData++; + if ((pData < pStop) && ((*pData == '\r') || (*pData == '\n'))) + pData++; + + // Emit any buffered last header field. + if (pMsgBuffer->Tell() > 0) + { + *pMsgBuffer << '\0'; + int status = PutMsgLine ( + (const sal_Char *) pMsgBuffer->GetData(), pMsgBuffer->Tell(), pCtx); + if (status != INETSTREAM_STATUS_OK) return status; + } + + // Reset to begin. + eOState = INETMSG_EOL_BEGIN; + pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN); + + // Mark header parsed. + bHeaderParsed = TRUE; + } + else if ((*pData == ' ') || (*pData == '\t')) + { + // Continuation line. Unfold multi-line field-body. + *pMsgBuffer << ' '; + pData++; + } + else + { + // Begin of new header field. + if (pMsgBuffer->Tell() > 0) + { + // Emit buffered header field now. + *pMsgBuffer << '\0'; + int status = PutMsgLine ( + (const sal_Char *) pMsgBuffer->GetData(), pMsgBuffer->Tell(), pCtx); + if (status != INETSTREAM_STATUS_OK) return status; + } + + // Reset to begin of buffer. + pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN); + + // Insert current character into buffer. + *pMsgBuffer << *pData++; + } + + // Search for next line break character. + if (!bHeaderParsed) eOState = INETMSG_EOL_SCR; + } + else if (eOState == INETMSG_EOL_FCR) + { + // Skip line break character. + pData++; + + // Mark begin of line. + eOState = INETMSG_EOL_BEGIN; + } + else if ((*pData == '\r') || (*pData == '\n')) + { + if (*pData == '\r') pData++; + eOState = INETMSG_EOL_FCR; + } + else if (rtl_char_isWhitespace (*pData & 0x7f)) + { + // Any <LWS> is folded into a single <SP> character. + sal_Char c = *((const sal_Char *) pMsgBuffer->GetData() + pMsgBuffer->Tell() - 1); + if (!rtl_char_isWhitespace (c & 0x7f)) *pMsgBuffer << ' '; + + // Skip over this <LWS> character. + pData++; + } + else + { + // Any other character is inserted into line buffer. + *pMsgBuffer << *pData++; + } + } + + if (bHeaderParsed && (pData < pStop)) + { + // Put message body down-stream. + return PutMsgLine (pData, (pStop - pData), pCtx); + } + + return INETSTREAM_STATUS_OK; +} + +/* + * PutMsgLine. + */ +int INetMessageOStream::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + // Check for message container. + if (pTargetMsg == NULL) return INETSTREAM_STATUS_ERROR; + + // Check for header or body. + if (!IsHeaderParsed()) + { + ByteString aField (pData); + USHORT nPos = aField.Search (':'); + if (nPos != STRING_NOTFOUND) + { + ByteString aName ( + aField.Copy (0, nPos)); + ByteString aValue ( + aField.Copy (nPos + 1, aField.Len() - nPos + 1)); + aValue.EraseLeadingChars (' '); + + pTargetMsg->SetHeaderField ( + INetMessageHeader (aName, aValue)); + } + } + else + { + SvOpenLockBytes *pLB = + PTR_CAST(SvOpenLockBytes, pTargetMsg->GetDocumentLB()); + if (pLB == NULL) + return INETSTREAM_STATUS_WOULDBLOCK; + + ULONG nDocSiz = pTargetMsg->GetDocumentSize(); + ULONG nWrite = 0; + + ErrCode status = pLB->FillAppend ((sal_Char *)pData, nSize, &nWrite); + pTargetMsg->SetDocumentSize (nDocSiz + nWrite); + + if (nWrite < nSize) return INETSTREAM_STATUS_ERROR; + } + return INETSTREAM_STATUS_OK; +} + +/*========================================================================= + * + * INetMessageIOStream Implementation. + * + *=======================================================================*/ +/* + * INetMessageIOStream. + */ +INetMessageIOStream::INetMessageIOStream (ULONG nBufferSize) + : INetMessageIStream (nBufferSize), + INetMessageOStream () +{ +} + +/* + * ~INetMessageIOStream. + */ +INetMessageIOStream::~INetMessageIOStream (void) +{ +} + +/*======================================================================= + * + * INetMessageEncodeQPStream_Impl Implementation. + * (Quoted-Printable Encoding) + * + *=====================================================================*/ +static const sal_Char hex2pr[16] = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + 'A', 'B', 'C', 'D', 'E', 'F' +}; + +static const sal_Char ebcdic[] = { + '!', '"', '#', '$', '@', '[', '\\', ']', '^', '`', '{', '|', '}', '~' +}; + +/* + * INetMessageEncodeQPStream_Impl. + */ +INetMessageEncodeQPStream_Impl::INetMessageEncodeQPStream_Impl ( + ULONG nMsgBufferSize) + : INetMessageIStream (), + pMsgStrm (NULL), + nMsgBufSiz (nMsgBufferSize), + nTokBufSiz (80), + eState (INETMSG_EOL_SCR), + bDone (FALSE) +{ + GenerateHeader (FALSE); + + pMsgBuffer = new sal_Char[nMsgBufSiz]; + pMsgRead = pMsgWrite = pMsgBuffer; + + pTokBuffer = new sal_Char[nTokBufSiz]; + pTokRead = pTokWrite = pTokBuffer; +} + +/* + * ~INetMessageEncodeQPStream_Impl. + */ +INetMessageEncodeQPStream_Impl::~INetMessageEncodeQPStream_Impl (void) +{ + delete pMsgStrm; + delete [] pMsgBuffer; + delete [] pTokBuffer; +} + +/* + * GetMsgLine. + */ +int INetMessageEncodeQPStream_Impl::GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx) +{ + INetMessage *pMsg = GetSourceMessage (); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + if (pMsg->GetDocumentLB() == NULL) return 0; + if (pMsgStrm == NULL) pMsgStrm = new SvStream (pMsg->GetDocumentLB()); + + sal_Char *pWBuf = pData; + while (pWBuf < (pData + nSize)) + { + // Caller's buffer not yet filled. + if ((pMsgRead - pMsgWrite) > 0) + { + // Bytes still in message buffer. + if ((eState != INETMSG_EOL_BEGIN) && + ((pTokRead - pTokBuffer) < 72)) + { + // Token buffer not yet filled. + if (eState == INETMSG_EOL_FCR) + { + eState = INETMSG_EOL_BEGIN; + if (*pMsgWrite != '\n') + { + // Convert orphant <CR> into <CR><LF> sequence. + *pTokRead++ = '\n'; + } + *pTokRead++ = *pMsgWrite++; + } + else if ((*pMsgWrite == ' ') || (*pMsgWrite == '\t')) + { + eState = INETMSG_EOL_FSP; + *pTokRead++ = *pMsgWrite++; + } + else if (*pMsgWrite == '\r') + { + // Found <CR>. + if (eState == INETMSG_EOL_FSP) + { + // Encode last (trailing space) character. + sal_uInt8 c = (sal_uInt8)(*(--pTokRead)); + *pTokRead++ = '='; + *pTokRead++ = hex2pr[((c & 0xf0) >> 4)]; + *pTokRead++ = hex2pr[((c & 0x0f) )]; + } + eState = INETMSG_EOL_FCR; + *pTokRead++ = *pMsgWrite++; + } + else if (*pMsgWrite == '\n') + { + // Found <LF> only. + if (eState == INETMSG_EOL_FSP) + { + // Encode last (trailing space) character. + sal_uInt8 c = (sal_uInt8)(*(--pTokRead)); + *pTokRead++ = '='; + *pTokRead++ = hex2pr[((c & 0xf0) >> 4)]; + *pTokRead++ = hex2pr[((c & 0x0f) )]; + } + eState = INETMSG_EOL_BEGIN; + + // Convert orphant <LF> into <CR><LF> sequence. + *pTokRead++ = '\r'; + *pTokRead++ = *pMsgWrite++; + } + else if (*pMsgWrite == '=') + { + // Escape character itself MUST be encoded, of course. + sal_uInt8 c = (sal_uInt8)(*pMsgWrite++); + *pTokRead++ = '='; + *pTokRead++ = hex2pr[((c & 0xf0) >> 4)]; + *pTokRead++ = hex2pr[((c & 0x0f) )]; + + eState = INETMSG_EOL_SCR; + } + else if (((sal_uInt8)(*pMsgWrite) > 0x20) && + ((sal_uInt8)(*pMsgWrite) < 0x7f) ) + { + /* + * Some printable ASCII character. + * (Encode EBCDIC special characters (NYI)). + */ + *pTokRead++ = *pMsgWrite++; + eState = INETMSG_EOL_SCR; + } + else + { + // Encode any other character. + sal_uInt8 c = (sal_uInt8)(*pMsgWrite++); + *pTokRead++ = '='; + *pTokRead++ = hex2pr[((c & 0xf0) >> 4)]; + *pTokRead++ = hex2pr[((c & 0x0f) )]; + + eState = INETMSG_EOL_SCR; + } + } + else + { + // Check for maximum line length. + if (eState != INETMSG_EOL_BEGIN) + { + // Insert soft line break. + *pTokRead++ = '='; + *pTokRead++ = '\r'; + *pTokRead++ = '\n'; + + eState = INETMSG_EOL_BEGIN; + } + + // Copy to caller's buffer. + if ((pTokRead - pTokWrite) > 0) + { + // Bytes still in token buffer. + *pWBuf++ = *pTokWrite++; + } + else + { + // Token buffer empty. Reset to <Begin-of-Buffer>. + pTokRead = pTokWrite = pTokBuffer; + eState = INETMSG_EOL_SCR; + } + } + } + else + { + // Message buffer empty. Reset to <Begin-of-Buffer>. + pMsgRead = pMsgWrite = pMsgBuffer; + + // Read next message block. + ULONG nRead = pMsgStrm->Read (pMsgBuffer, nMsgBufSiz); + if (nRead > 0) + { + // Set read pointer. + pMsgRead = (pMsgBuffer + nRead); + } + else + { + // Nothing more ro read. + if (!bDone) + { + // Append final <CR><LF> and mark we're done. + *pTokRead++ = '\r'; + *pTokRead++ = '\n'; + + bDone = TRUE; + } + else + { + // Already done all encoding. + if ((pTokRead - pTokWrite) > 0) + { + // Bytes still in token buffer. + *pWBuf++ = *pTokWrite++; + } + else + { + // Token buffer empty. Reset to <Begin-of-Buffer>. + pTokRead = pTokWrite = pTokBuffer; + + // Return. + return (pWBuf - pData); + } + } + } + } + } + return (pWBuf - pData); +} + +/*===================================================================== + * + * INetMessageDecodeQPStream_Impl Implementation. + * (Quoted-Printable Decoding) + * + *====================================================================*/ +static const sal_uInt8 pr2hex[128] = { + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + + 0x10, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 +}; + +/* + * INetMessageDecodeQPStream_Impl. + */ +INetMessageDecodeQPStream_Impl::INetMessageDecodeQPStream_Impl (void) + : INetMessageOStream (), + eState (INETMSG_EOL_BEGIN), + pMsgBuffer (new SvMemoryStream), + nTokBufLen (0) +{ + ParseHeader (FALSE); +} + +/* + * ~INetMessageDecodeQPStream_Impl. + */ +INetMessageDecodeQPStream_Impl::~INetMessageDecodeQPStream_Impl (void) +{ + delete pMsgBuffer; +} + +/* + * PutMsgLine. + */ +int INetMessageDecodeQPStream_Impl::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + INetMessage *pMsg = GetTargetMessage(); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + SvOpenLockBytes * pLB = PTR_CAST(SvOpenLockBytes, pMsg->GetDocumentLB()); + if (pLB == NULL) return INETSTREAM_STATUS_WOULDBLOCK; + + const sal_Char *pStop = pData + nSize; + while (pData < pStop) + { + if (eState == INETMSG_EOL_FESC) + { + *(pTokBuffer + nTokBufLen++) = toupper (*pData); + pData++; + if (nTokBufLen == 2) + { + if ((*pTokBuffer == '\r') || (*pTokBuffer == '\n')) + { + // Soft line break (=<CR><LF>). Emit buffer now. + eState = INETMSG_EOL_BEGIN; + } + else + { + // Decode token. + *pMsgBuffer << sal_uInt8 ( + (pr2hex[(int)(pTokBuffer[0] & 0x7f)] << 4) | + (pr2hex[(int)(pTokBuffer[1] & 0x7f)] & 15) ); + + // Search for next <CR>. + eState = INETMSG_EOL_SCR; + } + + // Reset token buffer. + nTokBufLen = 0; + } + } + else if (*pData == '=') + { + // Found escape character. + pData++; + eState = INETMSG_EOL_FESC; + } + else if (eState == INETMSG_EOL_FCR) + { + *pMsgBuffer << *pData++; + eState = INETMSG_EOL_BEGIN; + } + else if (*pData == '\r') + { + *pMsgBuffer << *pData++; + eState = INETMSG_EOL_FCR; + } + else + { + *pMsgBuffer << *pData++; + } + + if (eState == INETMSG_EOL_BEGIN) + { + ULONG nRead = pMsgBuffer->Tell(); + if (nRead > 0) + { + // Emit buffer. + ULONG nDocSiz = pMsg->GetDocumentSize(); + ULONG nWrite = 0; + + pLB->FillAppend ( + (sal_Char *)(pMsgBuffer->GetData()), nRead, &nWrite); + pMsg->SetDocumentSize (nDocSiz + nWrite); + + if (nWrite < nRead) return INETSTREAM_STATUS_ERROR; + + pMsgBuffer->Seek (STREAM_SEEK_TO_BEGIN); + } + eState = INETMSG_EOL_SCR; + } + } + return INETSTREAM_STATUS_OK; +} + +/*====================================================================== + * + * INetMessageEncode64Stream_Impl Implementation. + * (Base64 Encoding) + * + *====================================================================*/ +static const sal_Char six2pr[64] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', + 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' +}; + +/* + * INetMessageEncode64Stream_Impl. + */ +INetMessageEncode64Stream_Impl::INetMessageEncode64Stream_Impl ( + ULONG nMsgBufferSize) + : INetMessageIStream (), + pMsgStrm (NULL), + nMsgBufSiz (nMsgBufferSize), + nTokBufSiz (80), + bDone (FALSE) +{ + GenerateHeader (FALSE); + + pMsgBuffer = new sal_uInt8[nMsgBufSiz]; + pMsgRead = pMsgWrite = pMsgBuffer; + + pTokBuffer = new sal_Char[nTokBufSiz]; + pTokRead = pTokWrite = pTokBuffer; +} + +/* + * ~INetMessageEncode64Stream_Impl. + */ +INetMessageEncode64Stream_Impl::~INetMessageEncode64Stream_Impl (void) +{ + delete pMsgStrm; + delete [] pMsgBuffer; + delete [] pTokBuffer; +} + +/* + * GetMsgLine. + */ +int INetMessageEncode64Stream_Impl::GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx) +{ + INetMessage *pMsg = GetSourceMessage (); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + if (pMsg->GetDocumentLB() == NULL) return 0; + if (pMsgStrm == NULL) pMsgStrm = new SvStream (pMsg->GetDocumentLB()); + + sal_Char *pWBuf = pData; + while (pWBuf < (pData + nSize)) + { + // Caller's buffer not yet filled. + if ((pMsgRead - pMsgWrite) > 0) + { + // Bytes still in message buffer. + if ((pTokRead - pTokBuffer) < 72) + { + // Token buffer not yet filled. + switch ((pTokRead - pTokBuffer) % 4) + { + case 0: + *pTokRead++ = six2pr[(int)(*pMsgWrite >> 2)]; + break; + + case 1: + *pTokRead++ = six2pr[ + (int)(((*pMsgWrite << 4) & 060) | + (((*(pMsgWrite + 1)) >> 4) & 017))]; + pMsgWrite++; + break; + + case 2: + *pTokRead++ = six2pr[ + (int)(((*pMsgWrite << 2) & 074) | + (((*(pMsgWrite + 1)) >> 6) & 003))]; + pMsgWrite++; + break; + + default: // == case 3 + *pTokRead++ = six2pr[(int)(*pMsgWrite & 077)]; + pMsgWrite++; + break; + } + } + else if ((pTokRead - pTokBuffer) == 72) + { + // Maximum line length. Append <CR><LF>. + *pTokRead++ = '\r'; + *pTokRead++ = '\n'; + } + else + { + if ((pTokRead - pTokWrite) > 0) + { + // Bytes still in token buffer. + *pWBuf++ = *pTokWrite++; + } + else + { + // Token buffer empty. Reset to <Begin-of-Buffer>. + pTokRead = pTokWrite = pTokBuffer; + } + } + } + else + { + // Message buffer empty. Reset to <Begin-of-Buffer>. + pMsgRead = pMsgWrite = pMsgBuffer; + + // Read next message block. + ULONG nRead = pMsgStrm->Read (pMsgBuffer, nMsgBufSiz); + if (nRead > 0) + { + // Set read pointer. + pMsgRead = (pMsgBuffer + nRead); + } + else + { + // Nothing more to read. + if (!bDone) + { + // Append pad character(s) and final <CR><LF>. + switch ((pTokRead - pTokBuffer) % 4) + { + case 2: + *pTokRead++ = '='; + // Fall through for 2nd pad character. + + case 3: + *pTokRead++ = '='; + break; + + default: + break; + } + *pTokRead++ = '\r'; + *pTokRead++ = '\n'; + + // Mark we're done. + bDone = TRUE; + } + else + { + // Already done all encoding. + if ((pTokRead - pTokWrite) > 0) + { + // Bytes still in token buffer. + *pWBuf++ = *pTokWrite++; + } + else + { + // Token buffer empty. Reset to <Begin-of-Buffer>. + pTokRead = pTokWrite = pTokBuffer; + + // Reset done flag, if everything has been done. + // if (pWBuf == pData) bDone = FALSE; + + // Return. + return (pWBuf - pData); + } + } + } + } + } // while (pWBuf < (pData + nSize)) + return (pWBuf - pData); +} + +/*====================================================================== + * + * INetMessageDecode64Stream_Impl Implementation. + * (Base64 Decoding) + * + *====================================================================*/ +static const sal_uInt8 pr2six[256] = { + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x3E, 0x40, 0x40, 0x40, 0x3F, + 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, + 0x3C, 0x3D, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, + 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, + 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, + 0x17, 0x18, 0x19, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, + 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, + 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, + 0x31, 0x32, 0x33, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 +}; + +/* + * INetMessageDecode64Stream_Impl. + */ +INetMessageDecode64Stream_Impl::INetMessageDecode64Stream_Impl ( + ULONG nMsgBufferSize) + : INetMessageOStream (), + eState (INETMSG_EOL_SCR), + nMsgBufSiz (nMsgBufferSize) +{ + ParseHeader (FALSE); + + pMsgBuffer = new sal_Char[nMsgBufSiz]; + pMsgRead = pMsgWrite = pMsgBuffer; +} + +/* + * ~INetMessageDecode64Stream_Impl. + */ +INetMessageDecode64Stream_Impl::~INetMessageDecode64Stream_Impl (void) +{ + delete [] pMsgBuffer; +} + +/* + * PutMsgLine. + */ +int INetMessageDecode64Stream_Impl::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + INetMessage *pMsg = GetTargetMessage (); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + SvOpenLockBytes * pLB = PTR_CAST(SvOpenLockBytes, pMsg->GetDocumentLB()); + if (pLB == NULL) return INETSTREAM_STATUS_WOULDBLOCK; + + const sal_Char *pStop = (pData + nSize); + while (pData < pStop) + { + if (pr2six[(int)(*pData)] > 63) + { + /* + * Character not in base64 alphabet. + * Check for <End-of-Stream> or Junk. + */ + if (*pData == '=') + { + // Final pad character -> Done. + ULONG nDocSiz = pMsg->GetDocumentSize(); + ULONG nRead = pMsgWrite - pMsgBuffer; + ULONG nWrite = 0; + + pLB->FillAppend (pMsgBuffer, nRead, &nWrite); + pMsg->SetDocumentSize (nDocSiz + nWrite); + + if (nWrite < nRead) + return INETSTREAM_STATUS_ERROR; + else + return INETSTREAM_STATUS_LOADED; + } + else if (eState == INETMSG_EOL_FCR) + { + // Skip any line break character. + if ((*pData == '\r') || (*pData == '\n')) pData++; + + // Store decoded message buffer contents. + ULONG nDocSiz = pMsg->GetDocumentSize(); + ULONG nRead = pMsgWrite - pMsgBuffer; + ULONG nWrite = 0; + + pLB->FillAppend (pMsgBuffer, nRead, &nWrite); + pMsg->SetDocumentSize (nDocSiz + nWrite); + + if (nWrite < nRead) return INETSTREAM_STATUS_ERROR; + + // Reset to <Begin-of-Buffer>. + pMsgWrite = pMsgBuffer; + eState = INETMSG_EOL_SCR; + } + else if ((*pData == '\r') || (*pData == '\n')) + { + // Skip any line break character. + pData++; + eState = INETMSG_EOL_FCR; + } + else + { + // Skip any junk character (may be transmission error). + pData++; + } + } + else + { + // Decode any other character into message buffer. + switch ((pMsgRead - pMsgBuffer) % 4) + { + case 0: + *pMsgWrite = (pr2six[(int)(*pData++)] << 2); + pMsgRead++; + break; + + case 1: + *pMsgWrite++ |= (pr2six[(int)(*pData )] >> 4); + *pMsgWrite = (pr2six[(int)(*pData++)] << 4); + pMsgRead++; + break; + + case 2: + *pMsgWrite++ |= (pr2six[(int)(*pData )] >> 2); + *pMsgWrite = (pr2six[(int)(*pData++)] << 6); + pMsgRead++; + break; + + default: // == case 3 + *pMsgWrite++ |= (pr2six[(int)(*pData++)]); + pMsgRead = pMsgBuffer; + break; + } // switch ((pMsgRead - pMsgBuffer) % 4) + } + } // while (pData < pStop) + return INETSTREAM_STATUS_OK; +} + +/*========================================================================= + * + * INetMIMEMessageStream Implementation. + * + *=======================================================================*/ +/* + * INetMIMEMessageStream. + */ +INetMIMEMessageStream::INetMIMEMessageStream (ULONG nBufferSize) + : INetMessageIOStream (nBufferSize), + eState (INETMSG_EOL_BEGIN), + nChildIndex (0), + pChildStrm (NULL), + eEncoding (INETMSG_ENCODING_BINARY), + pEncodeStrm (NULL), + pDecodeStrm (NULL), + pMsgBuffer (NULL) +{ +} + +/* + * ~INetMIMEMessageStream. + */ +INetMIMEMessageStream::~INetMIMEMessageStream (void) +{ + delete pChildStrm; + delete pEncodeStrm; + delete pDecodeStrm; + delete pMsgBuffer; +} + +/* + * GetMsgEncoding. + */ +INetMessageEncoding +INetMIMEMessageStream::GetMsgEncoding (const String& rContentType) +{ + if ((rContentType.CompareIgnoreCaseToAscii ("message" , 7) == 0) || + (rContentType.CompareIgnoreCaseToAscii ("multipart", 9) == 0) ) + return INETMSG_ENCODING_7BIT; + + if (rContentType.CompareIgnoreCaseToAscii ("text", 4) == 0) + { + if (rContentType.CompareIgnoreCaseToAscii ("text/plain", 10) == 0) + { + if (rContentType.GetTokenCount ('=') > 1) + { + String aCharset (rContentType.GetToken (1, '=')); + aCharset.EraseLeadingChars (' '); + aCharset.EraseLeadingChars ('"'); + + if (aCharset.CompareIgnoreCaseToAscii ("us-ascii", 8) == 0) + return INETMSG_ENCODING_7BIT; + else + return INETMSG_ENCODING_QUOTED; + } + else + return INETMSG_ENCODING_7BIT; + } + else + return INETMSG_ENCODING_QUOTED; + } + + return INETMSG_ENCODING_BASE64; +} + +/* + * GetMsgLine. + * (Message Generator). + */ +int INetMIMEMessageStream::GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx) +{ + // Check for message container. + INetMIMEMessage *pMsg = GetSourceMessage(); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + // Check for header or body. + if (!IsHeaderGenerated()) + { + if (eState == INETMSG_EOL_BEGIN) + { + // Prepare special header fields. + if (pMsg->GetParent()) + { + String aPCT (pMsg->GetParent()->GetContentType()); + if (aPCT.CompareIgnoreCaseToAscii ("message/rfc822", 14) == 0) + pMsg->SetMIMEVersion ( + String(CONSTASCII_STRINGPARAM("1.0"))); + else + pMsg->SetMIMEVersion (String()); + } + else + { + pMsg->SetMIMEVersion (String(CONSTASCII_STRINGPARAM("1.0"))); + } + + // Check ContentType. + String aContentType (pMsg->GetContentType()); + if (aContentType.Len()) + { + // Determine default Content-Type. + String aDefaultType; + pMsg->GetDefaultContentType (aDefaultType); + + if (aDefaultType.CompareIgnoreCaseToAscii ( + aContentType, aContentType.Len()) == 0) + { + // No need to specify default. + pMsg->SetContentType (String()); + } + } + + // Check Encoding. + String aEncoding (pMsg->GetContentTransferEncoding()); + if (aEncoding.Len()) + { + // Use given Encoding. + if (aEncoding.CompareIgnoreCaseToAscii ( + "base64", 6) == 0) + eEncoding = INETMSG_ENCODING_BASE64; + else if (aEncoding.CompareIgnoreCaseToAscii ( + "quoted-printable", 16) == 0) + eEncoding = INETMSG_ENCODING_QUOTED; + else + eEncoding = INETMSG_ENCODING_7BIT; + } + else + { + // Use default Encoding for (given|default) Content-Type. + if (aContentType.Len() == 0) + { + // Determine default Content-Type. + pMsg->GetDefaultContentType (aContentType); + } + eEncoding = GetMsgEncoding (aContentType); + } + + // Set Content-Transfer-Encoding header. + if (eEncoding == INETMSG_ENCODING_BASE64) + { + // Base64. + pMsg->SetContentTransferEncoding ( + String(CONSTASCII_STRINGPARAM("base64"))); + } + else if (eEncoding == INETMSG_ENCODING_QUOTED) + { + // Quoted-Printable. + pMsg->SetContentTransferEncoding ( + String(CONSTASCII_STRINGPARAM("quoted-printable"))); + } + else + { + // No need to specify default. + pMsg->SetContentTransferEncoding (String()); + } + + // Mark we're done. + eState = INETMSG_EOL_DONE; + } + + // Generate the message header. + int nRead = INetMessageIOStream::GetMsgLine (pData, nSize, pCtx); + if (nRead <= 0) + { + // Reset state. + eState = INETMSG_EOL_BEGIN; + } + return nRead; + } + else + { + // Generate the message body. + if (pMsg->IsContainer()) + { + // Encapsulated message body. + while (eState == INETMSG_EOL_BEGIN) + { + if (pChildStrm == NULL) + { + INetMIMEMessage *pChild = pMsg->GetChild (nChildIndex); + if (pChild) + { + // Increment child index. + nChildIndex++; + + // Create child stream. + pChildStrm = new INetMIMEMessageStream; + pChildStrm->SetSourceMessage (pChild); + + if (pMsg->IsMultipart()) + { + // Insert multipart delimiter. + ByteString aDelim ("--"); + aDelim += pMsg->GetMultipartBoundary(); + aDelim += "\r\n"; + + rtl_copyMemory ( + pData, aDelim.GetBuffer(), aDelim.Len()); + return aDelim.Len(); + } + } + else + { + // No more parts. Mark we're done. + eState = INETMSG_EOL_DONE; + nChildIndex = 0; + + if (pMsg->IsMultipart()) + { + // Insert close delimiter. + ByteString aDelim ("--"); + aDelim += pMsg->GetMultipartBoundary(); + aDelim += "--\r\n"; + + rtl_copyMemory ( + pData, aDelim.GetBuffer(), aDelim.Len()); + return aDelim.Len(); + } + } + } + else + { + // Read current child stream. + int nRead = pChildStrm->Read (pData, nSize, pCtx); + if (nRead > 0) + { + return nRead; + } + else + { + // Cleanup exhausted child stream. + delete pChildStrm; + pChildStrm = NULL; + } + } + } + return 0; + } + else + { + // Single part message body. + if (pMsg->GetDocumentLB() == NULL) + { + // Empty message body. + return 0; + } + else + { + // Check whether message body needs to be encoded. + if (eEncoding == INETMSG_ENCODING_7BIT) + { + // No Encoding. + return INetMessageIOStream::GetMsgLine ( + pData, nSize, pCtx); + } + else + { + // Apply appropriate Encoding. + while (eState == INETMSG_EOL_BEGIN) + { + if (pEncodeStrm == NULL) + { + // Create encoder stream. + if (eEncoding == INETMSG_ENCODING_QUOTED) + { + // Quoted-Printable Encoding. + pEncodeStrm + = new INetMessageEncodeQPStream_Impl; + } + else + { + // Base64 Encoding. + pEncodeStrm + = new INetMessageEncode64Stream_Impl; + } + pEncodeStrm->SetSourceMessage (pMsg); + } + + // Read encoded message. + int nRead = pEncodeStrm->Read (pData, nSize, pCtx); + if (nRead > 0) + { + return nRead; + } + else + { + // Cleanup exhausted encoder stream. + delete pEncodeStrm; + pEncodeStrm = NULL; + + // Mark we're done. + eState = INETMSG_EOL_DONE; + } + } + return 0; + } + } + } + } + return INETSTREAM_STATUS_ERROR; // Never reached. +} + +/* + * PutMsgLine. + * (Message Parser). + */ +int INetMIMEMessageStream::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + // Check for message container. + INetMIMEMessage *pMsg = GetTargetMessage(); + if (pMsg == NULL) return INETSTREAM_STATUS_ERROR; + + // Check for header or body. + if (!IsHeaderParsed()) + { + // Parse the message header. + int nRet = INetMessageIOStream::PutMsgLine (pData, nSize, pCtx); + return nRet; + } + else + { + pMsg->SetHeaderParsed(); + // Parse the message body. + if (pMsg->IsContainer()) + { + + // Content-Transfer-Encoding MUST be "7bit" (RFC1521). + if (pMsg->IsMessage()) + { + if( !pChildStrm ) + { + // Encapsulated message. + pMsg->SetChildCount( pMsg->GetChildCount() + 1); + INetMIMEMessage* pNewMessage = new INetMIMEMessage; + pNewMessage->SetDocumentLB ( + new SvAsyncLockBytes(new SvCacheStream, FALSE)); + pMsg->AttachChild( *pNewMessage, TRUE ); + + // Encapsulated message body. Create message parser stream. + pChildStrm = new INetMIMEMessageStream; + pChildStrm->SetTargetMessage ( pNewMessage ); + + // Initialize control variables. + eState = INETMSG_EOL_BEGIN; + } + if ( nSize > 0) + { + // Bytes still in buffer. Put message down-stream. + int status = pChildStrm->Write( + pData, nSize, NULL ); + if (status != INETSTREAM_STATUS_OK) + return status; + } + + return INetMessageIOStream::PutMsgLine ( + pData, nSize, pCtx); + } + else + { + + // Multipart message body. Initialize multipart delimiters. + // Multipart message. + if (pMsg->GetMultipartBoundary().Len() == 0) + { + // Determine boundary. + ByteString aType ( + pMsg->GetContentType(), RTL_TEXTENCODING_ASCII_US); + ByteString aLowerType (aType); + aLowerType.ToLowerAscii(); + + USHORT nPos = aLowerType.Search ("boundary="); + ByteString aBoundary (aType.Copy (nPos + 9)); + + aBoundary.EraseLeadingAndTrailingChars (' '); + aBoundary.EraseLeadingAndTrailingChars ('"'); + + // Save boundary. + pMsg->SetMultipartBoundary (aBoundary); + } + + ByteString aPlainDelim (pMsg->GetMultipartBoundary()); + ByteString aDelim ("--"); + aDelim += aPlainDelim; + + ByteString aPlainClose (aPlainDelim); + aPlainClose += "--"; + + ByteString aClose (aDelim); + aClose += "--"; + + if (pMsgBuffer == NULL) pMsgBuffer = new SvMemoryStream; + pMsgBuffer->Write (pData, nSize); + ULONG nBufSize = pMsgBuffer->Tell(); + + const sal_Char* pChar; + const sal_Char* pOldPos; + for( pOldPos = pChar = (const sal_Char *) pMsgBuffer->GetData(); nBufSize--; + pChar++ ) + { + int status; + if( *pChar == '\r' || *pChar == '\n' ) + { + if( aDelim.CompareTo (pOldPos, aDelim.Len()) + != COMPARE_EQUAL && + aClose.CompareTo (pOldPos, aClose.Len()) + != COMPARE_EQUAL && + aPlainDelim.CompareTo (pOldPos, aPlainDelim.Len()) + != COMPARE_EQUAL && + aPlainClose.CompareTo(pOldPos, aPlainClose.Len()) + != COMPARE_EQUAL ) + { + if( nBufSize && + ( pChar[1] == '\r' || pChar[1] == '\n' ) ) + nBufSize--, pChar++; + if( pChildStrm ) + { + status = pChildStrm->Write( + pOldPos, pChar - pOldPos + 1 ); + if( status != INETSTREAM_STATUS_OK ) + return status; + } + else + DBG_ERRORFILE( "Die Boundary nicht gefunden" ); + status = INetMessageIOStream::PutMsgLine( + pOldPos, pChar - pOldPos + 1, pCtx ); + if( status != INETSTREAM_STATUS_OK ) + return status; + pOldPos = pChar + 1; + } + else + { + if( nBufSize && + ( pChar[1] == '\r' || pChar[1] == '\n' ) ) + nBufSize--, pChar++; + pOldPos = pChar + 1; + DELETEZ( pChildStrm ); + + if (aClose.CompareTo (pOldPos, aClose.Len()) + != COMPARE_EQUAL && + aPlainClose.CompareTo (pOldPos, aClose.Len()) + != COMPARE_EQUAL ) + { + // Encapsulated message. + pMsg->SetChildCount(pMsg->GetChildCount() + 1); + INetMIMEMessage* pNewMessage = + new INetMIMEMessage; + pNewMessage->SetDocumentLB ( + new SvAsyncLockBytes ( + new SvCacheStream, FALSE)); + + pMsg->AttachChild( *pNewMessage, TRUE ); + + // Encapsulated message body. Create message parser stream. + pChildStrm = new INetMIMEMessageStream; + pChildStrm->SetTargetMessage ( pNewMessage ); + + // Initialize control variables. + } + eState = INETMSG_EOL_BEGIN; + status = INetMessageIOStream::PutMsgLine( + pOldPos, pChar - pOldPos + 1, pCtx ); + if( status != INETSTREAM_STATUS_OK ) + return status; + } + } + } + if( pOldPos < pChar ) + { + SvMemoryStream* pNewStream = new SvMemoryStream; + pNewStream->Write( pOldPos, pChar - pOldPos ); + SvMemoryStream* pTmp = pMsgBuffer; + pMsgBuffer = pNewStream; + delete pTmp; + } + else + { + pMsgBuffer->Seek( 0L ); + pMsgBuffer->SetStreamSize( 0 ); + } + return INETSTREAM_STATUS_OK; + } + } + else + { + /* + * Single part message. + * Remove any ContentTransferEncoding. + */ + if (pMsg->GetContentType().Len() == 0) + { + String aDefaultCT; + pMsg->GetDefaultContentType (aDefaultCT); + pMsg->SetContentType (aDefaultCT); + } + + if (eEncoding == INETMSG_ENCODING_BINARY) + { + String aEncoding (pMsg->GetContentTransferEncoding()); + if (aEncoding.CompareIgnoreCaseToAscii ( + "base64", 6) == COMPARE_EQUAL) + eEncoding = INETMSG_ENCODING_BASE64; + else if (aEncoding.CompareIgnoreCaseToAscii ( + "quoted-printable", 16) == COMPARE_EQUAL) + eEncoding = INETMSG_ENCODING_QUOTED; + else + eEncoding = INETMSG_ENCODING_7BIT; + } + + if (eEncoding == INETMSG_ENCODING_7BIT) + { + // No decoding necessary. + return INetMessageIOStream::PutMsgLine ( + pData, nSize, pCtx); + } + else + { + if (pDecodeStrm == NULL) + { + if (eEncoding == INETMSG_ENCODING_QUOTED) + pDecodeStrm = new INetMessageDecodeQPStream_Impl; + else + pDecodeStrm = new INetMessageDecode64Stream_Impl; + + pDecodeStrm->SetTargetMessage (pMsg); + } + return pDecodeStrm->Write (pData, nSize, pCtx); + } + } + } +} + +/*========================================================================= + * + * INetMessageDecodeGZStream_Impl Implementation. + * (GZIP Decoding). + * + *=======================================================================*/ +class INetMessageDecodeGZStream_Impl : public INetMessageOStream +{ + SvMemoryStream m_aStrm; + GZCodec m_aCodec; + sal_uInt8 m_pBuffer[1024]; + + virtual int PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx = NULL); + +public: + INetMessageDecodeGZStream_Impl (void); +}; + +/* + * INetMessageDecodeGZStream_Impl. + */ +INetMessageDecodeGZStream_Impl::INetMessageDecodeGZStream_Impl (void) + : INetMessageOStream() +{ + ParseHeader (FALSE); + m_aCodec.BeginCompression(); +} + +/* + * PutMsgLine. + */ +int INetMessageDecodeGZStream_Impl::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + INetMessage *pMsg = GetTargetMessage(); + if (pMsg == NULL) + return INETSTREAM_STATUS_ERROR; + + SvOpenLockBytes * pLB = PTR_CAST(SvOpenLockBytes, pMsg->GetDocumentLB()); + if (pLB == NULL) + return INETSTREAM_STATUS_WOULDBLOCK; + + m_aStrm.Seek (STREAM_SEEK_TO_BEGIN); + m_aStrm.Write (pData, nSize); + + m_aStrm.Seek (STREAM_SEEK_TO_BEGIN); + long nRead = 0; + + // Decode into buffer. + m_aCodec.SetBreak (nSize); + while ((nRead = m_aCodec.Read (m_aStrm, m_pBuffer, sizeof(m_pBuffer))) > 0) + { + // Emit Buffer. + ULONG nDocSize = pMsg->GetDocumentSize(); + ULONG nWrite = 0; + + pLB->FillAppend (m_pBuffer, nRead, &nWrite); + pMsg->SetDocumentSize (nDocSize + nWrite); + + if ((long)nWrite < nRead) + return INETSTREAM_STATUS_ERROR; + } + + if (m_aCodec.IsFinished()) + return INETSTREAM_STATUS_LOADED; + else if (nRead < 0) + return INETSTREAM_STATUS_ERROR; + else + return INETSTREAM_STATUS_OK; +} + +/*========================================================================= + * + * INetHTTPMessageStream Implementation. + * + *=======================================================================*/ +/* + * INetHTTPMessageStream. + */ +INetHTTPMessageStream::INetHTTPMessageStream (ULONG nBufferSize) + : INetMIMEMessageStream (nBufferSize), + m_eState (INETMSG_EOL_BEGIN), + m_pDecodeStrm (NULL) +{ +} + +/* + * ~INetHTTPMessageStream. + */ +INetHTTPMessageStream::~INetHTTPMessageStream (void) +{ + delete m_pDecodeStrm; +} + +/* + * GetMsgLine. + * (Message Generator). + */ +int INetHTTPMessageStream::GetMsgLine ( + sal_Char *pData, ULONG nSize, void *pCtx) +{ + // Check for header generation. + if (!IsHeaderGenerated()) + { + if (m_eState == INETMSG_EOL_BEGIN) + { + // Check for message container. + INetHTTPMessage *pMsg = GetSourceMessage(); + if (pMsg == NULL) + return INETSTREAM_STATUS_ERROR; + + // Set Accept-Encoding header. + pMsg->SetAcceptEncoding ( + String ("gzip", RTL_TEXTENCODING_ASCII_US)); + + // Mark done. + m_eState = INETMSG_EOL_DONE; + } + } + + // Initial approximation: Generate as plain message (w/o encoding). + return INetMessageIOStream::GetMsgLine (pData, nSize, pCtx); +} + +/* + * PutMsgLine. + * (Message Parser). + */ +int INetHTTPMessageStream::PutMsgLine ( + const sal_Char *pData, ULONG nSize, void *pCtx) +{ + // Check for header or body. + if (!IsHeaderParsed()) + { + // Parse the message header. + return INetMessageIOStream::PutMsgLine (pData, nSize, pCtx); + } + else + { + // Parse the message body. + if (m_eState == INETMSG_EOL_BEGIN) + { + // Check for message container. + INetHTTPMessage *pMsg = GetTargetMessage(); + if (pMsg == NULL) + return INETSTREAM_STATUS_ERROR; + + // Obtain ContentEncoding. + String aEncoding (pMsg->GetContentEncoding()); + aEncoding.EraseLeadingChars (' '); + + // Check for supported encoding. + if ((aEncoding.CompareIgnoreCaseToAscii ("gzip") == 0) || + (aEncoding.CompareIgnoreCaseToAscii ("x-gzip") == 0) ) + { + // Initialize decode stream. + m_pDecodeStrm = new INetMessageDecodeGZStream_Impl; + m_pDecodeStrm->SetTargetMessage (pMsg); + } + + // Mark done. + m_eState = INETMSG_EOL_DONE; + } + + // Check for Decode stream. + if (m_pDecodeStrm) + { + // Decode. + return m_pDecodeStrm->Write (pData, nSize, pCtx); + } + else + { + // No decoding necessary. + return INetMessageIOStream::PutMsgLine (pData, nSize, pCtx); + } + } +} + diff --git a/tools/source/inet/makefile.mk b/tools/source/inet/makefile.mk new file mode 100644 index 000000000000..74926210cd36 --- /dev/null +++ b/tools/source/inet/makefile.mk @@ -0,0 +1,83 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ = ..$/.. +PRJNAME = tools +TARGET = inet + +.INCLUDE: svpre.mk +.INCLUDE: settings.mk +.INCLUDE: sv.mk + +SLOFILES=\ + $(SLO)$/inetmime.obj \ + $(SLO)$/inetmsg.obj \ + $(SLO)$/inetstrm.obj + +.IF "$(UPDATER)" != "" +OBJFILES=\ + $(OBJ)$/inetmime.obj \ + $(OBJ)$/inetmsg.obj \ + $(OBJ)$/inetstrm.obj +.ENDIF + +.INCLUDE: target.mk diff --git a/tools/source/makefile.mk b/tools/source/makefile.mk new file mode 100644 index 000000000000..d340637a4f27 --- /dev/null +++ b/tools/source/makefile.mk @@ -0,0 +1,96 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:05 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=.. + +TARGET=source + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +.IF "$(GUI)" == "UNX" +SUBDIRS+= solar +.ENDIF + +SUBDIRS+= \ + datetime \ + timestamp \ + debug \ + fsys \ + generic \ + intntl \ + memmgr \ + memtools \ + misc \ + rc \ + ref \ + stream \ + zcodec + + +.INCLUDE : target.mk + diff --git a/tools/source/memtools/contnr.cxx b/tools/source/memtools/contnr.cxx new file mode 100644 index 000000000000..8228ecb4c880 --- /dev/null +++ b/tools/source/memtools/contnr.cxx @@ -0,0 +1,1754 @@ +/************************************************************************* + * + * $RCSfile: contnr.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define private public +#define protected public + +#ifndef _LIMITS_H +#include <limits.h> +#endif + +#ifndef _STRING_H +#include <string.h> +#endif + +#ifndef _STDIO_H +#include <stdio.h> +#endif + +#ifndef _SOLAR_H +#include <solar.h> +#endif + +#ifndef _IMPCONT_HXX +#include <impcont.hxx> +#endif + +#ifndef _CONTNR_HXX +#include <contnr.hxx> +#endif + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif + +// ----------------------------------------------------------------------- + +DBG_NAME( CBlock ); +DBG_NAME( Container ); + +/************************************************************************* +|* +|* DbgCheckCBlock() +|* +|* Beschreibung Pruefung eines CBlock fuer Debug-Utilities +|* Ersterstellung MI 30.01.92 +|* Letzte Aenderung TH 24.01.96 +|* +*************************************************************************/ + +#ifdef DBG_UTIL +const char* DbgCheckCBlock( const void* pBlock ) +{ + CBlock* p = (CBlock*)pBlock; + + if ( p->nCount > p->nSize ) + return "nCount > nSize"; + + if ( p->nSize && !p->pNodes ) + return "nSize > 0 && pNodes == NULL"; + + return NULL; +} +#endif + +/************************************************************************* +|* +|* CBlock::CBlock() +|* +|* Beschreibung Construktor des Verwaltungsblocks +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +CBlock::CBlock( USHORT nInitSize, CBlock* _pPrev, CBlock* _pNext ) +{ + DBG_CTOR( CBlock, DbgCheckCBlock ); + + pPrev = _pPrev; + pNext = _pNext; + nSize = nInitSize; + nCount = 0; + + // Datenpuffer anlegen + pNodes = (void**)new PVOID[nSize]; +} + +/************************************************************************* +|* +|* CBlock::CBlock() +|* +|* Beschreibung Construktor des Verwaltungsblocks +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +CBlock::CBlock( USHORT _nSize, CBlock* _pPrev ) +{ + DBG_CTOR( CBlock, DbgCheckCBlock ); + DBG_ASSERT( _nSize, "CBlock::CBlock(): nSize == 0" ); + + pPrev = _pPrev; + pNext = NULL; + nSize = _nSize; + nCount = _nSize; + + // Datenpuffer anlegen und initialisieren + pNodes = (void**)new PVOID[nSize]; + memset( pNodes, 0, nSize*sizeof(PVOID) ); +} + +/************************************************************************* +|* +|* CBlock::CBlock() +|* +|* Beschreibung Copy-Construktor des Verwaltungsblocks +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +CBlock::CBlock( const CBlock& r, CBlock* _pPrev ) +{ + DBG_CTOR( CBlock, DbgCheckCBlock ); + DBG_CHKOBJ( &r, CBlock, DbgCheckCBlock ); + + pPrev = _pPrev; + pNext = NULL; + nSize = r.nSize; + nCount = r.nCount; + + // Datenpuffer anlegen und Daten kopieren + pNodes = (void**)new PVOID[nSize]; + memcpy( pNodes, r.pNodes, nCount*sizeof(PVOID) ); +} + +/************************************************************************* +|* +|* CBlock::~CBlock() +|* +|* Beschreibung Destruktor des Verwaltungsblocks +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +inline CBlock::~CBlock() +{ + DBG_DTOR( CBlock, DbgCheckCBlock ); + + // Daten loeschen + delete pNodes; +} + +/************************************************************************* +|* +|* CBlock::Insert() +|* +|* Beschreibung Fuegt einen Pointer ein +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void CBlock::Insert( void* p, USHORT nIndex, USHORT nReSize ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + DBG_ASSERT( nIndex <= nCount, "CBlock::Insert(): Index > nCount" ); + + // Muss Block realokiert werden + if ( nCount == nSize ) + { + // Neue Daten anlegen + nSize += nReSize; + void** pNewNodes = (void**)new PVOID[nSize]; + + // Wird angehaengt + if ( nCount == nIndex ) + { + // Daten kopieren + memcpy( pNewNodes, pNodes, nCount*sizeof(PVOID) ); + } + else + { + // Daten kopieren + memcpy( pNewNodes, pNodes, nIndex*sizeof(PVOID) ); + memcpy( pNewNodes + nIndex + 1, + pNodes + nIndex, + (nCount-nIndex)*sizeof(PVOID) ); + } + + // Alte Daten loeschen und neue setzen + delete pNodes; + pNodes = pNewNodes; + } + else + { + if ( nIndex < nCount ) + { + memmove( pNodes + nIndex + 1, + pNodes + nIndex, + (nCount-nIndex)*sizeof(PVOID) ); + } + } + + // Neuen Pointer setzen und Elementgroesse erhoehen + pNodes[nIndex] = p; + nCount++; +} + +/************************************************************************* +|* +|* CBlock::Split() +|* +|* Beschreibung Fuegt einen Pointer ein und splittet den Block +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +CBlock* CBlock::Split( void* p, USHORT nIndex, USHORT nReSize ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + + USHORT nNewSize; + USHORT nMiddle; + CBlock* pNewBlock; + + nMiddle = nCount/2; + + if ( ( nIndex == nCount ) || ( nIndex == 0 ) ) + nNewSize = nReSize; + else + { + // Der aktuelle Block wird in der Mitte geteilt + nNewSize = (nCount+1) / 2; + + if ( nNewSize < nReSize ) + nNewSize = nReSize; + else + { + // Neue Groesse muss ein vielfaches von Resize sein + if ( nNewSize % nReSize ) + nNewSize += nReSize - (nNewSize % nReSize); + else + nNewSize += nReSize; + } + } + + // Vor oder hinter dem aktuellem Block einfuegen? + if ( nIndex > nMiddle ) + { + // Neuen Split-Block anlegen und hinter dem aktuellem Block einfuegen + pNewBlock = new CBlock( nNewSize, this, pNext ); + + if ( pNext ) + pNext->pPrev = pNewBlock; + pNext = pNewBlock; + + if ( nIndex == nCount ) + { + // Neuen Pointer einfuegen + pNewBlock->pNodes[0] = p; + pNewBlock->nCount = 1; + } + else + { + nIndex -= nMiddle; + // Alles von Mitte bis Index kopieren + if ( nIndex ) + memcpy( pNewBlock->pNodes, pNodes+nMiddle, nIndex*sizeof(PVOID) ); + + // Neuen Pointer einfuegen + pNewBlock->pNodes[nIndex] = p; + + // Alles von Mitte bis Ende hinter Index kopieren + memcpy( pNewBlock->pNodes+nIndex+1, + pNodes+nMiddle+nIndex, + (nCount-nMiddle-nIndex) * sizeof(PVOID) ); + + pNewBlock->nCount = (nCount-nMiddle+1); + nCount = nMiddle; + + // Den aktuellen Datenbereich auch halbieren + if ( nSize != nNewSize ) + { + void** pNewNodes = (void**)new PVOID[nNewSize]; + memcpy( pNewNodes, pNodes, nCount*sizeof(PVOID) ); + delete pNodes; + pNodes = pNewNodes; + nSize = nNewSize; + } + } + } + else + { + // Neuen Split-Block anlegen und vor dem aktuellem Block einfuegen + pNewBlock = new CBlock( nNewSize, pPrev, this ); + + if ( pPrev ) + pPrev->pNext = pNewBlock; + pPrev = pNewBlock; + + if ( nIndex == 0 ) + { + // Neuen Pointer einfuegen + pNewBlock->pNodes[0] = p; + pNewBlock->nCount = 1; + } + else + { + // Alles von Anfang bis Index kopieren + memcpy( pNewBlock->pNodes, pNodes, nIndex*sizeof(PVOID) ); + + // Neuen Pointer einfuegen + pNewBlock->pNodes[nIndex] = p; + + // Alles von Index bis Mitte hinter Index kopieren + if ( nIndex != nMiddle ) + { + memcpy( pNewBlock->pNodes+nIndex+1, + pNodes+nIndex, + (nMiddle-nIndex) * sizeof(PVOID) ); + } + + pNewBlock->nCount = nMiddle+1; + nCount -= nMiddle; + + // Die zweite Haelfte in einen neuen Block kopieren + if ( nSize != nNewSize ) + { + void** pNewNodes = (void**)new PVOID[nNewSize]; + memcpy( pNewNodes, pNodes+nMiddle, nCount*sizeof(PVOID) ); + delete pNodes; + pNodes = pNewNodes; + nSize = nNewSize; + } + else + memmove( pNodes, pNodes+nMiddle, nCount*sizeof(PVOID) ); + } + } + + // Neu angelegten Block zurueckgeben, da gegebenfalls die Blockpointer + // im Container angepast werden koennen + return pNewBlock; +} + +/************************************************************************* +|* +|* CBlock::Remove() +|* +|* Beschreibung Entfernt einen Pointer +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* CBlock::Remove( USHORT nIndex, USHORT nReSize ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + + // Alten Pointer sichern + void* pOld = pNodes[nIndex]; + + // 1 Element weniger + nCount--; + + // Block verkleinern (wenn Reallokationsgroesse um 4 unterschritten wird) + if ( nCount == (nSize-nReSize-4) ) + { + // Neue Daten anlegen + nSize -= nReSize; + void** pNewNodes = (void**)new PVOID[nSize]; + + // Wird letzter Eintrag geloescht + if ( nIndex == nCount ) + { + // Daten kopieren + memcpy( pNewNodes, pNodes, nCount*sizeof(PVOID) ); + } + else + { + // Daten kopieren + memcpy( pNewNodes, pNodes, nIndex*sizeof(PVOID) ); + memcpy( pNewNodes + nIndex, pNodes + nIndex+1, + (nCount-nIndex)*sizeof(PVOID) ); + } + + // Alte Daten loeschen und neue setzen + delete pNodes; + pNodes = pNewNodes; + } + else + { + // Wenn nicht das letzte Element, dann zusammenschieben + if ( nIndex < nCount ) + { + memmove( pNodes + nIndex, pNodes + nIndex + 1, + (nCount-nIndex)*sizeof(PVOID) ); + } + } + + // Alten Pointer zurueckgeben + return pOld; +} + +/************************************************************************* +|* +|* CBlock::Replace() +|* +|* Beschreibung Ersetzt einen Pointer +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +inline void* CBlock::Replace( void* p, USHORT nIndex ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + + // Alten Pointer sichern, neuen setzen und alten zurueckgeben + void* pOld = pNodes[nIndex]; + pNodes[nIndex] = p; + return pOld; +} + +/************************************************************************* +|* +|* CBlock::GetObjectPtr() +|* +|* Beschreibung Gibt einen Pointer auf den Pointer aus dem Block +|* zurueck +|* Ersterstellung TH 26.01.93 +|* Letzte Aenderung TH 26.01.93 +|* +*************************************************************************/ + +inline void** CBlock::GetObjectPtr( USHORT nIndex ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + + return &(pNodes[nIndex]); +} + +/************************************************************************* +|* +|* CBlock::SetSize() +|* +|* Beschreibung Aendert die Groesse des Blocks +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void CBlock::SetSize( USHORT nNewSize ) +{ + DBG_CHKTHIS( CBlock, DbgCheckCBlock ); + DBG_ASSERT( nNewSize, "CBlock::SetSize(): nNewSize == 0" ); + + // Unterscheidet sich die Groesse + if ( nNewSize != nCount ) + { + // Array erweitern + void** pNewNodes = new PVOID[nNewSize]; + + // Alte Tabelle in die Neue kopieren + if ( nNewSize < nCount ) + memcpy( pNewNodes, pNodes, nNewSize*sizeof(PVOID) ); + else + { + memcpy( pNewNodes, pNodes, nCount*sizeof(PVOID) ); + + // Array mit 0 initialisieren + memset( pNewNodes+nCount, 0, (nNewSize-nCount)*sizeof(PVOID) ); + } + + // Altes Array loeschen und neue Werte setzen + nSize = nNewSize; + nCount = nSize; + delete pNodes; + pNodes = pNewNodes; + } +} + +//------------------------------------------------------------------------ + +/************************************************************************* +|* +|* DbgCheckContainer() +|* +|* Beschreibung Pruefung eines Container fuer Debug-Utilities +|* Ersterstellung MI 30.01.92 +|* Letzte Aenderung TH 24.01.96 +|* +*************************************************************************/ + +#ifdef DBG_UTIL +const char* DbgCheckContainer( const void* pCont ) +{ + Container* p = (Container*)pCont; + + if ( p->nCount && (!p->pFirstBlock || !p->pLastBlock || !p->pCurBlock) ) + return "nCount > 0 but no CBlocks"; + + return NULL; +} +#endif + +/************************************************************************* +|* +|* ImpCopyContainer() +|* +|* Beschreibung Kopiert alle Daten des Containers +|* Ersterstellung TH 24.01.96 +|* Letzte Aenderung TH 24.01.96 +|* +*************************************************************************/ + +static void ImpCopyContainer( Container* pCont1, const Container* pCont2 ) +{ + // Werte vom uebergebenen Container uebernehmen + pCont1->nCount = pCont2->nCount; + pCont1->nCurIndex = pCont2->nCurIndex; + pCont1->nInitSize = pCont2->nInitSize; + pCont1->nReSize = pCont2->nReSize; + pCont1->nBlockSize = pCont2->nBlockSize; + + // Alle Bloecke kopieren + if ( pCont2->nCount ) + { + CBlock* pBlock1; + CBlock* pBlock2; + CBlock* pTempBlock; + + // Erstmal ersten Block kopieren + pBlock2 = pCont2->pFirstBlock; + pCont1->pFirstBlock = new CBlock( *pBlock2, NULL ); + // Ist erster Block der Current-Block, dann Current-Block setzen + if ( pBlock2 == pCont2->pCurBlock ) + pCont1->pCurBlock = pCont1->pFirstBlock; + pBlock1 = pCont1->pFirstBlock; + pBlock2 = pBlock2->GetNextBlock(); + while ( pBlock2 ) + { + // Neuen Block anlegen und aus der uebergebenen Liste kopieren + pTempBlock = new CBlock( *pBlock2, pBlock1 ); + pBlock1->SetNextBlock( pTempBlock ); + pBlock1 = pTempBlock; + + // Current-Block beruecksichtigen + if ( pBlock2 == pCont2->pCurBlock ) + pCont1->pCurBlock = pBlock1; + + // Auf naechsten Block weitersetzen + pBlock2 = pBlock2->GetNextBlock(); + } + + // Letzten Block setzen + pCont1->pLastBlock = pBlock1; + } + else + { + pCont1->pFirstBlock = NULL; + pCont1->pLastBlock = NULL; + pCont1->pCurBlock = NULL; + } +} + +/************************************************************************* +|* +|* Container::Container() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +Container::Container( USHORT _nBlockSize, USHORT _nInitSize, USHORT _nReSize ) +{ + DBG_CTOR( Container, DbgCheckContainer ); + + // BlockSize muss mindestens 4 sein und kleiner als 64 KB + if ( _nBlockSize < 4 ) + nBlockSize = 4; + else + { + if ( _nBlockSize < CONTAINER_MAXBLOCKSIZE ) + nBlockSize = _nBlockSize; + else + nBlockSize = CONTAINER_MAXBLOCKSIZE; + } + + // ReSize muss mindestens 2 sein und kleiner als BlockSize + if ( _nReSize >= nBlockSize ) + nReSize = nBlockSize; + else + { + if ( _nReSize < 2 ) + nReSize = 2; + else + nReSize = _nReSize; + + // BlockSize muss ein vielfaches der Resizegroesse sein + if ( nBlockSize % nReSize ) + nBlockSize -= nReSize - (nBlockSize % nReSize); + } + + // InitSize muss groesser gleich ReSize sein und kleiner als BlockSize + if ( _nInitSize <= nReSize ) + nInitSize = nReSize; + else + { + if ( _nInitSize >= nBlockSize ) + nInitSize = nBlockSize; + else + { + nInitSize = _nInitSize; + + // InitSize muss ein vielfaches der Resizegroesse sein + if ( nInitSize % nReSize ) + nInitSize -= nReSize - (nInitSize % nReSize); + } + } + + // Werte initialisieren + pFirstBlock = NULL; + pLastBlock = NULL; + pCurBlock = NULL; + nCount = 0; + nCurIndex = 0; +} + +/************************************************************************* +|* +|* Container::Container() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +Container::Container( ULONG nSize ) +{ + DBG_CTOR( Container, DbgCheckContainer ); + + nCount = nSize; + nCurIndex = 0; + nBlockSize = CONTAINER_MAXBLOCKSIZE; + nInitSize = 1; + nReSize = 1; + + if ( !nSize ) + { + pFirstBlock = NULL; + pLastBlock = NULL; + pCurBlock = NULL; + } + else + { + // Muss mehr als ein Block angelegt werden + if ( nSize <= nBlockSize ) + { + pFirstBlock = new CBlock( (USHORT)nSize, NULL ); + pLastBlock = pFirstBlock; + } + else + { + CBlock* pBlock1; + CBlock* pBlock2; + + pFirstBlock = new CBlock( nBlockSize, NULL ); + pBlock1 = pFirstBlock; + nSize -= nBlockSize; + + // Solange die Blockgroesse ueberschritten wird, neue Bloecke anlegen + while ( nSize > nBlockSize ) + { + pBlock2 = new CBlock( nBlockSize, pBlock1 ); + pBlock1->SetNextBlock( pBlock2 ); + pBlock1 = pBlock2; + nSize -= nBlockSize; + } + + pLastBlock = new CBlock( (USHORT)nSize, pBlock1 ); + pBlock1->SetNextBlock( pLastBlock ); + } + + pCurBlock = pFirstBlock; + } +} + +/************************************************************************* +|* +|* Container::Container() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +Container::Container( const Container& r ) +{ + DBG_CTOR( Container, DbgCheckContainer ); + + // Daten kopieren + ImpCopyContainer( this, &r ); +} + +/************************************************************************* +|* +|* Container::~Container() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +Container::~Container() +{ + DBG_DTOR( Container, DbgCheckContainer ); + + // Alle Bloecke loeschen + CBlock* pBlock = pFirstBlock; + while ( pBlock ) + { + CBlock* pTemp = pBlock->GetNextBlock(); + delete pBlock; + pBlock = pTemp; + } +} + +/************************************************************************* +|* +|* Container::ImpInsert() +|* +|* Beschreibung Interne Methode zum Einfuegen eines Pointers +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung DV 01.07.97 +|* +*************************************************************************/ + +void Container::ImpInsert( void* p, CBlock* pBlock, USHORT nIndex ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + if ( !nCount ) + { + if ( !pBlock ) + { + pFirstBlock = new CBlock( nInitSize, NULL, NULL ); + pLastBlock = pFirstBlock; + pCurBlock = pFirstBlock; + } + pFirstBlock->Insert( p, nIndex, nReSize ); + } + else + { + // Ist im Block die maximale Blockgroesse erreicht, + // dann neuen Block anlegen + if ( pBlock->Count() == nBlockSize ) + { + // Block auftrennen + CBlock* pNewBlock = pBlock->Split( p, nIndex, nReSize ); + + // Wurde Block dahinter angehaegnt + if ( pBlock->pNext == pNewBlock ) + { + // Gegebenenfalls LastBlock anpassen + if ( pBlock == pLastBlock ) + pLastBlock = pNewBlock; + + // Current-Position nachfuehren + if ( pBlock == pCurBlock ) + { + if ( pBlock->nCount <= nCurIndex ) + { + if ( nIndex <= nCurIndex ) + nCurIndex++; + pCurBlock = pNewBlock; + nCurIndex -= pBlock->nCount; + } + } + } + else + { + // Gegebenenfalls FirstBlock anpassen + if ( pBlock == pFirstBlock ) + pFirstBlock = pNewBlock; + + // Current-Position nachfuehren + if ( pBlock == pCurBlock ) + { + if ( nIndex <= nCurIndex ) + nCurIndex++; + if ( pNewBlock->nCount <= nCurIndex ) + nCurIndex -= pNewBlock->nCount; + else + pCurBlock = pNewBlock; + } + } + } + else + { + // Sonst reicht normales einfuegen in den Block + pBlock->Insert( p, nIndex, nReSize ); + + // Current-Position nachfuehren + if ( (pBlock == pCurBlock) && (nIndex <= nCurIndex) ) + nCurIndex++; + } + } + + // Ein neues Item im Container + nCount++; +} + +/************************************************************************* +|* +|* Container::Insert() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void Container::Insert( void* p ) +{ + ImpInsert( p, pCurBlock, nCurIndex ); +} + +/************************************************************************* +|* +|* Container::Insert() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void Container::Insert( void* p, ULONG nIndex ) +{ + if ( nCount <= nIndex ) + { + if ( pLastBlock ) + ImpInsert( p, pLastBlock, pLastBlock->Count() ); + else + ImpInsert( p, NULL, 0 ); + } + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() < nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + ImpInsert( p, pTemp, (USHORT)nIndex ); + } +} + +/************************************************************************* +|* +|* Container::Insert() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void Container::Insert( void* pNew, void* pOld ) +{ + ULONG nIndex = GetPos( pOld ); + if ( nIndex != CONTAINER_ENTRY_NOTFOUND ) + Insert( pNew, nIndex ); +} + +/************************************************************************* +|* +|* Container::ImpRemove() +|* +|* Beschreibung Interne Methode zum Entfernen eines Pointers +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::ImpRemove( CBlock* pBlock, USHORT nIndex ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + void* pOld; + + // Ist Liste danach leer + if ( nCount == 1 ) + { + // Block und CurIndex zuruecksetzen + pOld = pBlock->GetObject( nIndex ); + pBlock->Reset(); + nCurIndex = 0; + } + else + { + // Ist Block nach Remove leer + if ( pBlock->Count() == 1 ) + { + // dann Block entfernen und Block-Pointer umsetzen + if ( pBlock->GetPrevBlock() ) + (pBlock->GetPrevBlock())->SetNextBlock( pBlock->GetNextBlock() ); + else + pFirstBlock = pBlock->GetNextBlock(); + + if ( pBlock->GetNextBlock() ) + (pBlock->GetNextBlock())->SetPrevBlock( pBlock->GetPrevBlock() ); + else + pLastBlock = pBlock->GetPrevBlock(); + + // Current-Position nachfuehren + if ( pBlock == pCurBlock ) + { + if ( pBlock->GetNextBlock() ) + { + pCurBlock = pBlock->GetNextBlock(); + nCurIndex = 0; + } + else + { + pCurBlock = pBlock->GetPrevBlock(); + nCurIndex = pCurBlock->Count()-1; + } + } + + pOld = pBlock->GetObject( nIndex ); + delete pBlock; + } + else + { + // Sonst Item aus dem Block entfernen + pOld = pBlock->Remove( nIndex, nReSize ); + + // Current-Position nachfuehren + if ( (pBlock == pCurBlock) && + ((nIndex < nCurIndex) || ((nCurIndex == pBlock->Count()) && nCurIndex)) ) + nCurIndex--; + } + } + + // Jetzt gibt es ein Item weniger + nCount--; + + // Und den Pointer zurueckgeben, der entfernt wurde + return pOld; +} + +/************************************************************************* +|* +|* Container::Remove() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Remove() +{ + // Wenn kein Item vorhanden ist, NULL zurueckgeben + if ( !nCount ) + return NULL; + else + return ImpRemove( pCurBlock, nCurIndex ); +} + +/************************************************************************* +|* +|* Container::Remove() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Remove( ULONG nIndex ) +{ + // Ist Index nicht innerhalb des Containers, dann NULL zurueckgeben + if ( nCount <= nIndex ) + return NULL; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() <= nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + return ImpRemove( pTemp, (USHORT)nIndex ); + } +} + +/************************************************************************* +|* +|* Container::Replace() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Replace( void* p ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + if ( !nCount ) + return NULL; + else + return pCurBlock->Replace( p, nCurIndex ); +} + +/************************************************************************* +|* +|* Container::Replace() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Replace( void* p, ULONG nIndex ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Index nicht innerhalb des Containers, dann NULL zurueckgeben + if ( nCount <= nIndex ) + return NULL; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() <= nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + return pTemp->Replace( p, (USHORT)nIndex ); + } +} + +/************************************************************************* +|* +|* Container::SetSize() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void Container::SetSize( ULONG nNewSize ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + if ( nNewSize ) + { + // Unterscheiden sich die Groessen + if ( nNewSize != nCount ) + { + CBlock* pTemp; + ULONG nTemp; + + // Wird verkleinert + if ( nNewSize < nCount ) + { + pTemp = pFirstBlock; + nTemp = 0; + while ( (nTemp+pTemp->Count()) < nNewSize ) + { + nTemp += pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + // Alle folgenden Bloecke loeschen + BOOL bLast = FALSE; + CBlock* pDelNext; + CBlock* pDelBlock = pTemp->GetNextBlock(); + while ( pDelBlock ) + { + // Muss CurrentBlock umgesetzt werden + if ( pDelBlock == pCurBlock ) + bLast = TRUE; + pDelNext = pDelBlock->GetNextBlock(); + delete pDelBlock; + pDelBlock = pDelNext; + } + + // Block in der Groesse anpassen, oder bei Groesse 0 loeschen + if ( nNewSize > nTemp ) + { + pLastBlock = pTemp; + pTemp->SetNextBlock( NULL ); + pTemp->SetSize( (USHORT)(nNewSize-nTemp) ); + } + else + { + pLastBlock = pTemp->GetPrevBlock(); + pLastBlock->SetNextBlock( NULL ); + delete pTemp; + } + + nCount = nNewSize; + if ( bLast ) + { + pCurBlock = pLastBlock; + nCurIndex = pCurBlock->Count()-1; + } + } + else + { + // Auf den letzen Puffer setzen + pTemp = pLastBlock; + nTemp = nNewSize - nCount; + + if ( !pTemp ) + { + // Muss mehr als ein Block angelegt werden + if ( nNewSize <= nBlockSize ) + { + pFirstBlock = new CBlock( (USHORT)nNewSize, NULL ); + pLastBlock = pFirstBlock; + } + else + { + CBlock* pBlock1; + CBlock* pBlock2; + + pFirstBlock = new CBlock( nBlockSize, NULL ); + pBlock1 = pFirstBlock; + nNewSize -= nBlockSize; + + // Solange die Blockgroesse ueberschritten wird, neue Bloecke anlegen + while ( nNewSize > nBlockSize ) + { + pBlock2 = new CBlock( nBlockSize, pBlock1 ); + pBlock1->SetNextBlock( pBlock2 ); + pBlock1 = pBlock2; + nNewSize -= nBlockSize; + } + + pLastBlock = new CBlock( (USHORT)nNewSize, pBlock1 ); + pBlock1->SetNextBlock( pLastBlock ); + } + + pCurBlock = pFirstBlock; + } + // Reicht es, den letzen Puffer in der Groesse anzupassen + else if ( (nTemp+pTemp->Count()) <= nBlockSize ) + pTemp->SetSize( (USHORT)(nTemp+pTemp->Count()) ); + else + { + // Puffer auf max. Blockgroesse setzen + nTemp -= nBlockSize - pTemp->GetSize(); + pTemp->SetSize( nBlockSize ); + + CBlock* pTemp2; + // Solange die Blockgroesse ueberschritten wird, + // neue Bloecke anlegen + while ( nTemp > nBlockSize ) + { + pTemp2 = new CBlock( nBlockSize, pTemp ); + pTemp->SetNextBlock( pTemp2 ); + pTemp = pTemp2; + nTemp -= nBlockSize; + } + + // Den letzten Block anlegen + if ( nTemp ) + { + pLastBlock = new CBlock( (USHORT)nTemp, pTemp ); + pTemp->SetNextBlock( pLastBlock ); + } + else + pLastBlock = pTemp; + } + + nCount = nNewSize; + } + } + } + else + Clear(); +} + +/************************************************************************* +|* +|* Container::Clear() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void Container::Clear() +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Erst alle Bloecke loeschen + CBlock* pBlock = pFirstBlock; + while ( pBlock ) + { + CBlock* pTemp = pBlock->GetNextBlock(); + delete pBlock; + pBlock = pTemp; + } + + // Werte zuruecksetzen + pFirstBlock = NULL; + pLastBlock = NULL; + pCurBlock = NULL; + nCount = 0; + nCurIndex = 0; +} + +/************************************************************************* +|* +|* Container::GetCurObject() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::GetCurObject() const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // NULL, wenn Container leer + if ( !nCount ) + return NULL; + else + return pCurBlock->GetObject( nCurIndex ); +} + +/************************************************************************* +|* +|* Container::GetCurPos() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +ULONG Container::GetCurPos() const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // CONTAINER_ENTRY_NOTFOUND, wenn Container leer + if ( !nCount ) + return CONTAINER_ENTRY_NOTFOUND; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + ULONG nTemp = 0; + while ( pTemp != pCurBlock ) + { + nTemp += pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + return nTemp+nCurIndex; + } +} + +/************************************************************************* +|* +|* Container::GetObjectPtr() +|* +|* Beschreibung Interne Methode fuer Referenz-Container +|* Ersterstellung TH 26.01.93 +|* Letzte Aenderung TH 26.01.93 +|* +*************************************************************************/ + +void** Container::GetObjectPtr( ULONG nIndex ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Index nicht innerhalb des Containers, dann NULL zurueckgeben + if ( nCount <= nIndex ) + return NULL; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() <= nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + // Item innerhalb des gefundenen Blocks zurueckgeben + return pTemp->GetObjectPtr( (USHORT)nIndex ); + } +} + +/************************************************************************* +|* +|* Container::GetObject() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::GetObject( ULONG nIndex ) const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Index nicht innerhalb des Containers, dann NULL zurueckgeben + if ( nCount <= nIndex ) + return NULL; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() <= nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + // Item innerhalb des gefundenen Blocks zurueckgeben + return pTemp->GetObject( (USHORT)nIndex ); + } +} + +/************************************************************************* +|* +|* Container::GetPos() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +ULONG Container::GetPos( const void* p ) const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + void** pNodes; + CBlock* pTemp; + ULONG nTemp; + USHORT nBlockCount; + USHORT i; + + // Block suchen + pTemp = pFirstBlock; + nTemp = 0; + while ( pTemp ) + { + pNodes = pTemp->GetNodes(); + i = 0; + nBlockCount = pTemp->Count(); + while ( i < nBlockCount ) + { + if ( p == *pNodes ) + return nTemp+i; + pNodes++; + i++; + } + nTemp += nBlockCount; + pTemp = pTemp->GetNextBlock(); + } + + return CONTAINER_ENTRY_NOTFOUND; +} + +/************************************************************************* +|* +|* Container::GetPos() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 14.09.94 +|* Letzte Aenderung TH 14.09.94 +|* +*************************************************************************/ + +ULONG Container::GetPos( const void* p, ULONG nStartIndex, + BOOL bForward ) const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Index nicht innerhalb des Containers, dann NOTFOUND zurueckgeben + if ( nCount <= nStartIndex ) + return CONTAINER_ENTRY_NOTFOUND; + else + { + void** pNodes; + USHORT nBlockCount; + USHORT i; + + // Block suchen + CBlock* pTemp = pFirstBlock; + ULONG nTemp = 0; + while ( nTemp+pTemp->Count() <= nStartIndex ) + { + nTemp += pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + // Jetzt den Pointer suchen + if ( bForward ) + { + // Alle Bloecke durchrsuchen + i = (USHORT)(nStartIndex - nTemp); + pNodes = pTemp->GetObjectPtr( i ); + do + { + nBlockCount = pTemp->Count(); + while ( i < nBlockCount ) + { + if ( p == *pNodes ) + return nTemp+i; + pNodes++; + i++; + } + nTemp += nBlockCount; + pTemp = pTemp->GetNextBlock(); + if ( pTemp ) + { + i = 0; + pNodes = pTemp->GetNodes(); + } + else + break; + } + while ( TRUE ); + } + else + { + // Alle Bloecke durchrsuchen + i = (USHORT)(nStartIndex-nTemp)+1; + pNodes = pTemp->GetObjectPtr( i-1 ); + do + { + do + { + if ( p == *pNodes ) + return nTemp+i-1; + pNodes--; + i--; + } + while ( i ); + nTemp -= pTemp->Count(); + pTemp = pTemp->GetPrevBlock(); + if ( pTemp ) + { + i = pTemp->Count(); + // Leere Bloecke in der Kette darf es nicht geben. Nur + // wenn ein Block existiert, darf dieser leer sein + pNodes = pTemp->GetObjectPtr( i-1 ); + } + else + break; + } + while ( TRUE ); + } + } + + return CONTAINER_ENTRY_NOTFOUND; +} + +/************************************************************************* +|* +|* Container::Seek() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Seek( ULONG nIndex ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist der Container leer, dann NULL zurueckgeben + if ( nCount <= nIndex ) + return NULL; + else + { + // Block suchen + CBlock* pTemp = pFirstBlock; + while ( pTemp->Count() <= nIndex ) + { + nIndex -= pTemp->Count(); + pTemp = pTemp->GetNextBlock(); + } + + // Item innerhalb des gefundenen Blocks zurueckgeben + pCurBlock = pTemp; + nCurIndex = (USHORT)nIndex; + return pCurBlock->GetObject( nCurIndex ); + } +} + +/************************************************************************* +|* +|* Container::First() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::First() +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Container leer, dann NULL zurueckgeben + if ( !nCount ) + return NULL; + else + { + // Block und Index setzen und ersten Pointer zurueckgeben + pCurBlock = pFirstBlock; + nCurIndex = 0; + return pCurBlock->GetObject( nCurIndex ); + } +} + +/************************************************************************* +|* +|* Container::Last() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Last() +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Container leer, dann NULL zurueckgeben + if ( !nCount ) + return NULL; + else + { + // Block und Index setzen und ersten Pointer zurueckgeben + pCurBlock = pLastBlock; + nCurIndex = pCurBlock->Count()-1; + return pCurBlock->GetObject( nCurIndex ); + } +} + +/************************************************************************* +|* +|* Container::Next() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Next() +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Container leer, dann NULL zurueckgeben, ansonsten preufen ob + // naechste Position noch im aktuellen Block ist. Falls nicht, dann + // einen Block weiterschalten (geht ohne Gefahr, da leere Bloecke + // nicht vorkommen duerfen, es sein denn, es ist der einzige). + if ( !nCount ) + return NULL; + else if ( (nCurIndex+1) < pCurBlock->Count() ) + return pCurBlock->GetObject( ++nCurIndex ); + else if ( pCurBlock->GetNextBlock() ) + { + pCurBlock = pCurBlock->GetNextBlock(); + nCurIndex = 0; + return pCurBlock->GetObject( nCurIndex ); + } + else + return NULL; +} + +/************************************************************************* +|* +|* Container::Prev() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +void* Container::Prev() +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Ist Container leer, dann NULL zurueckgeben, ansonsten preufen ob + // vorherige Position noch im aktuellen Block ist. Falls nicht, dann + // einen Block zurueckschalten (geht ohne Gefahr, da leere Bloecke + // nicht vorkommen duerfen, es sein denn, es ist der einzige). + if ( !nCount ) + return NULL; + else if ( nCurIndex ) + return pCurBlock->GetObject( --nCurIndex ); + else if ( pCurBlock->GetPrevBlock() ) + { + pCurBlock = pCurBlock->GetPrevBlock(); + nCurIndex = pCurBlock->Count() - 1; + return pCurBlock->GetObject( nCurIndex ); + } + else + return NULL; +} + +/************************************************************************* +|* +|* Container::operator =() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +Container& Container::operator =( const Container& r ) +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + // Erst alle Bloecke loeschen + CBlock* pBlock = pFirstBlock; + while ( pBlock ) + { + CBlock* pTemp = pBlock->GetNextBlock(); + delete pBlock; + pBlock = pTemp; + } + + // Daten kopieren + ImpCopyContainer( this, &r ); + return *this; +} + +/************************************************************************* +|* +|* Container::operator ==() +|* +|* Beschreibung CONTNR.SDW +|* Ersterstellung TH 17.09.91 +|* Letzte Aenderung TH 17.09.91 +|* +*************************************************************************/ + +BOOL Container::operator ==( const Container& r ) const +{ + DBG_CHKTHIS( Container, DbgCheckContainer ); + + if ( nCount != r.nCount ) + return FALSE; + + ULONG i = 0; + while ( i < nCount ) + { + if ( GetObject( i ) != r.GetObject( i ) ) + return FALSE; + i++; + } + + return TRUE; +} diff --git a/tools/source/memtools/makefile.mk b/tools/source/memtools/makefile.mk new file mode 100644 index 000000000000..bc8e84bf15b1 --- /dev/null +++ b/tools/source/memtools/makefile.mk @@ -0,0 +1,92 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=mtools + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/contnr.obj \ + $(SLO)$/table.obj \ + $(SLO)$/unqidx.obj \ + $(SLO)$/mempool.obj \ + $(SLO)$/multisel.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/contnr.obj \ + $(OBJ)$/table.obj \ + $(OBJ)$/unqidx.obj \ + $(OBJ)$/mempool.obj \ + $(OBJ)$/multisel.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/memtools/mempool.cxx b/tools/source/memtools/mempool.cxx new file mode 100644 index 000000000000..25d4149bcdb4 --- /dev/null +++ b/tools/source/memtools/mempool.cxx @@ -0,0 +1,323 @@ +/************************************************************************* + * + * $RCSfile: mempool.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define private public + +#include <limits.h> + +#include <debug.hxx> +#include <mempool.hxx> + +// ----------------------------------------------------------------------- + +#if ( __ALIGNMENT8 > 4 ) +#define MEMPOOL_ALIGNMENT __ALIGNMENT8 +#else +#define MEMPOOL_ALIGNMENT 4 +#endif + +// ----------------- +// - FixedMemBlock - +// ----------------- + +struct FixedMemBlock +{ + USHORT nSize; + USHORT nFree; + USHORT nFirst; + USHORT nDummyAlign1; + FixedMemBlock* pNext; +#if (__SIZEOFPOINTER == 4) && (__ALIGNMENT8 == 8) + void* pDummyAlign2; +#endif + char aData[1]; +}; + +/************************************************************************* +|* +|* ImpDbgPoolTest() +|* +|* Beschreibung MEMPOOL.SDW +|* Ersterstellung TH 30.11.94 +|* Letzte Aenderung TH 30.11.94 +|* +*************************************************************************/ + +#ifdef DBG_UTIL + +static void ImpDbgPoolTest( FixedMemPool* pMemPool ) +{ + DbgData* pData = DbgGetData(); + + if ( !pData ) + return; + + if ( !(pData->nTestFlags & (DBG_TEST_MEM_OVERWRITE | DBG_TEST_MEM_OVERWRITEFREE)) ) + return; + + FixedMemBlock* pFirst = pMemPool->pFirst; + FixedMemBlock* pBlock = pFirst; + while ( pBlock ) + { + if ( pBlock->nFree ) + { + USHORT i = pBlock->nFree; + USHORT n = pBlock->nFirst; + char* pData = pBlock->aData; + while ( i ) + { + if ( !(n < (pBlock->nSize/pMemPool->nTypeSize)) ) + DbgError( "MemPool: Memory Overwrite" ); + + char* pNext = pData+(n*pMemPool->nTypeSize); + n = *((USHORT*)pNext); + i--; + } + } + + pBlock = pBlock->pNext; + } +} + +#endif + +/************************************************************************* +|* +|* FixedMemPool::FixedMemPool() +|* +|* Beschreibung MEMPOOL.SDW +|* Ersterstellung TH 02.09.94 +|* Letzte Aenderung TH 02.09.94 +|* +*************************************************************************/ + +FixedMemPool::FixedMemPool( USHORT _nTypeSize, + USHORT _nInitSize, USHORT _nGrowSize ) +{ + pFirst = NULL; + nInitSize = _nInitSize; + nGrowSize = _nGrowSize; + + if ( _nTypeSize > 4 ) + nTypeSize = (_nTypeSize + (MEMPOOL_ALIGNMENT-1)) & ~(MEMPOOL_ALIGNMENT-1); + else if ( _nTypeSize <= 2 ) + nTypeSize = 2; + else + nTypeSize = 4; + + DBG_ASSERT( (ULONG)nTypeSize*nInitSize <= USHRT_MAX, + "FixedMemPool: TypeSize*nInitSize > USHRT_MAX" ); + DBG_ASSERT( (ULONG)nTypeSize*nGrowSize <= USHRT_MAX, + "FixedMemPool: TypeSize*GrowSize > USHRT_MAX" ); +} + +/************************************************************************* +|* +|* FixedMemPool::~FixedMemPool() +|* +|* Beschreibung MEMPOOL.SDW +|* Ersterstellung TH 02.09.94 +|* Letzte Aenderung TH 02.09.94 +|* +*************************************************************************/ + +FixedMemPool::~FixedMemPool() +{ + FixedMemBlock* pBlock = pFirst; + while ( pBlock ) + { + FixedMemBlock* pTemp = pBlock; + pBlock = pBlock->pNext; + delete pTemp; + } +} + +/************************************************************************* +|* +|* FixedMemPool::Alloc() +|* +|* Beschreibung MEMPOOL.SDW +|* Ersterstellung TH 02.09.94 +|* Letzte Aenderung TH 02.09.94 +|* +*************************************************************************/ + +void* FixedMemPool::Alloc() +{ +#ifdef DBG_UTIL + ImpDbgPoolTest( this ); +#endif + + USHORT i; + char* pData; + + if ( !pFirst ) + { + pFirst = (FixedMemBlock*)new char[sizeof(FixedMemBlock)-1+(nInitSize*nTypeSize)]; + + if ( !pFirst ) + return NULL; + + pFirst->pNext = NULL; + pFirst->nSize = nInitSize*nTypeSize;; + pFirst->nFree = nInitSize-1; + pFirst->nFirst = 1; + + pData = pFirst->aData; + for ( i = 1; i < nInitSize; i++ ) + { + *((USHORT*)pData) = i; + pData += nTypeSize; + } + + return (void*)(pFirst->aData); + } + + FixedMemBlock* pBlock = pFirst; + while ( pBlock && !pBlock->nFree ) + pBlock = pBlock->pNext; + + if ( pBlock ) + { + pData = pBlock->aData; + char* pFree = pData+(pBlock->nFirst*nTypeSize); + pBlock->nFirst = *((USHORT*)pFree); // UMR, wenn letzter freier Block, ist OK + pBlock->nFree--; + return (void*)pFree; + } + else + { + if ( !nGrowSize ) + return NULL; + + pBlock = (FixedMemBlock*)new char[sizeof(FixedMemBlock)-1+(nGrowSize*nTypeSize)]; + + if ( !pBlock ) + return NULL; + + pData = pBlock->aData; + for ( i = 1; i < nGrowSize; i++ ) + { + *((USHORT*)pData) = i; + pData += nTypeSize; + } + + pBlock->pNext = pFirst->pNext; + pBlock->nSize = nGrowSize*nTypeSize; + pBlock->nFree = nGrowSize-1; + pBlock->nFirst = 1; + pFirst->pNext = pBlock; + + return (void*)(pBlock->aData); + } +} + +/************************************************************************* +|* +|* FixedMemPool::Free() +|* +|* Beschreibung MEMPOOL.SDW +|* Ersterstellung TH 02.09.94 +|* Letzte Aenderung TH 02.09.94 +|* +*************************************************************************/ + +void FixedMemPool::Free( void* pFree ) +{ + if ( !pFree ) + return; + +#ifdef DBG_UTIL + ImpDbgPoolTest( this ); +#endif + + FixedMemBlock* pBlock = pFirst; + FixedMemBlock* pPrev = NULL; + while ( ((ULONG)pBlock->aData > (ULONG)pFree) || + ((ULONG)pFree >= ((ULONG)pBlock->aData+pBlock->nSize)) ) + { + pPrev = pBlock; + pBlock = pBlock->pNext; + +#ifdef DBG_UTIL + DBG_ASSERT( pBlock, "FixedMemPool - Delete: Wrong Pointer" ); +#endif + } + + pBlock->nFree++; + *((USHORT*)pFree) = pBlock->nFirst; + pBlock->nFirst = (USHORT)(((ULONG)pFree-(ULONG)(pBlock->aData)) / nTypeSize); + + if ( pPrev && (pBlock->nFree*nTypeSize == pBlock->nSize) ) + { + pPrev->pNext = pBlock->pNext; + delete pBlock; + } + else + { + if ( pPrev ) + { + pPrev->pNext = pBlock->pNext; + pBlock->pNext = pFirst->pNext; + pFirst->pNext = pBlock; + } + } +} diff --git a/tools/source/memtools/multisel.cxx b/tools/source/memtools/multisel.cxx new file mode 100644 index 000000000000..8bd47a028019 --- /dev/null +++ b/tools/source/memtools/multisel.cxx @@ -0,0 +1,897 @@ +/************************************************************************* + * + * $RCSfile: multisel.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _SV_MULTISEL_CXX + +#ifdef MI_DEBUG +#define private public +#include <stdio.h> +#endif + +#include <debug.hxx> +#include <multisel.hxx> + +#pragma hdrstop + +#ifdef MI_DEBUG +#define DBG(x) x +#else +#define DBG(x) +#endif + +//================================================================== + +#ifdef MI_DEBUG + +static void Print( const MultiSelection* pSel ) +{ + DbgOutf( "TotRange: %4ld-%4ld\n", + pSel->aTotRange.Min(), pSel->aTotRange.Max() ); + if ( pSel->bCurValid ) + { + DbgOutf( "CurSubSel: %4ld\n", pSel->nCurSubSel ); + DbgOutf( "CurIndex: %4ld\n", pSel->nCurIndex ); + } + DbgOutf( "SelCount: %4ld\n", pSel->nSelCount ); + DbgOutf( "SubCount: %4ld\n", pSel->aSels.Count() ); + for ( ULONG nPos = 0; nPos < pSel->aSels.Count(); ++nPos ) + { + DbgOutf( "SubSel #%2ld: %4ld-%4ld\n", nPos, + pSel->aSels.GetObject(nPos)->Min(), + pSel->aSels.GetObject(nPos)->Max() ); + } + DbgOutf( "\n" ); + fclose( pFile ); +} + +#endif + +// ----------------------------------------------------------------------- + +void MultiSelection::ImplClear() +{ + // no selected indexes + nSelCount = 0; + + Range* pRange = aSels.First(); + while ( pRange ) + { + delete pRange; + pRange = aSels.Next(); + } + aSels.Clear(); +} + +// ----------------------------------------------------------------------- + +ULONG MultiSelection::ImplFindSubSelection( long nIndex ) const +{ + // iterate through the sub selections + ULONG n = 0; + for ( ; + n < aSels.Count() && nIndex > aSels.GetObject(n)->Max(); + ++n ) {} /* empty loop */ + return n; +} + +// ----------------------------------------------------------------------- + +BOOL MultiSelection::ImplMergeSubSelections( ULONG nPos1, ULONG nPos2 ) +{ + // didn't a sub selection at nPos2 exist? + if ( nPos2 >= aSels.Count() ) + return FALSE; + + // did the sub selections touch each other? + if ( (aSels.GetObject(nPos1)->Max() + 1) == aSels.GetObject(nPos2)->Min() ) + { + // merge them + aSels.GetObject(nPos1)->Max() = aSels.GetObject(nPos2)->Max(); + delete aSels.Remove(nPos2); + return TRUE; + } + + return FALSE; +} + +// ----------------------------------------------------------------------- + +MultiSelection::MultiSelection(): + aTotRange( 0, -1 ), + nSelCount(0), + nCurSubSel(0), + bCurValid(FALSE), + bSelectNew(FALSE) +{ +} + +// ----------------------------------------------------------------------- + +MultiSelection::MultiSelection( const UniString& rString, sal_Unicode cRange, sal_Unicode cSep ): + aTotRange(0,RANGE_MAX), + nSelCount(0), + nCurSubSel(0), + bCurValid(FALSE), + bSelectNew(FALSE) +{ + // Dies ist nur ein Schnellschuss und sollte bald optimiert, + // an die verschiedenen Systeme (MAC, UNIX etc.) + // und die gewuenschte Eingabe-Syntax angepasst werden. + + UniString aStr( rString ); + sal_Unicode* pStr = aStr.GetBufferAccess(); + sal_Unicode* pOld = pStr; + BOOL bReady = FALSE; + BOOL bUntil = FALSE; + xub_StrLen nCut = 0; + + // Hier normieren wir den String, sodass nur Ziffern, + // Semikola als Trenn- und Minus als VonBis-Zeichen + // uebrigbleiben, z.B. "99-117;55;34;-17;37-43" + while ( *pOld ) + { + switch( *pOld ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + DBG_ASSERT( *pOld != cRange, "digit for range char not allowed" ); + DBG_ASSERT( *pOld != cSep, "digit for separator not allowed" ); + if( bReady ) + { + *pStr++ = ';'; + nCut++; + bReady = FALSE; + } + *pStr++ = *pOld; + nCut++; + bUntil = FALSE; + break; + + case '-': + case ':': + case '/': + if ( *pOld != cSep ) + { + if ( !bUntil ) + { + *pStr++ = '-'; + nCut++; + bUntil = TRUE; + } + bReady = FALSE; + } + else + bReady = TRUE; + break; + + case ' ': + DBG_ASSERT( *pOld != cRange, "SPACE for range char not allowed" ); + DBG_ASSERT( *pOld != cSep, "SPACE for separator not allowed" ); + bReady = !bUntil; + break; + + default: + if ( *pOld == cRange ) + { + if ( !bUntil ) + { + *pStr++ = '-'; + nCut++; + bUntil = TRUE; + } + bReady = FALSE; + } + else + bReady = TRUE; + break; + } + + pOld++; + } + aStr.ReleaseBufferAccess( nCut ); + + // Jetzt wird der normierte String ausgewertet .. + UniString aNumStr; + Range aRg( 1, RANGE_MAX ); + const sal_Unicode* pCStr = aStr.GetBuffer(); + long nPage = 1; + long nNum = 1; + bUntil = FALSE; + while ( *pCStr ) + { + switch ( *pCStr ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + aNumStr += *pCStr; + break; + case ';': + nNum = aNumStr.ToInt32(); + if ( bUntil ) + { + if ( !aNumStr.Len() ) + nNum = RANGE_MAX; + aRg.Min() = nPage; + aRg.Max() = nNum; + aRg.Justify(); + Select( aRg ); + } + else + Select( nNum ); + nPage = 0; + aNumStr.Erase(); + bUntil = FALSE; + break; + + case '-': + nPage = aNumStr.ToInt32(); + aNumStr.Erase(); + bUntil = TRUE; + break; + } + + pCStr++; + } + + nNum = aNumStr.ToInt32(); + if ( bUntil ) + { + if ( !aNumStr.Len() ) + nNum = RANGE_MAX; + aRg.Min() = nPage; + aRg.Max() = nNum; + aRg.Justify(); + Select( aRg ); + } + else + Select( nNum ); +} + +// ----------------------------------------------------------------------- + +MultiSelection::MultiSelection( const MultiSelection& rOrig ) : + aTotRange(rOrig.aTotRange), + bCurValid(rOrig.bCurValid), + nSelCount(rOrig.nSelCount), + bSelectNew(FALSE) +{ + if ( bCurValid ) + { + nCurSubSel = rOrig.nCurSubSel; + nCurIndex = rOrig.nCurIndex; + } + + // copy the sub selections + for ( ULONG n = 0; n < rOrig.aSels.Count(); ++n ) + aSels.Insert( new Range( *rOrig.aSels.GetObject(n) ), LIST_APPEND ); +} + +// ----------------------------------------------------------------------- + +MultiSelection::MultiSelection( const Range& rRange ): + aTotRange(rRange), + nSelCount(0), + nCurSubSel(0), + bCurValid(FALSE), + bSelectNew(FALSE) +{ +} + +// ----------------------------------------------------------------------- + +MultiSelection::~MultiSelection() +{ + Range* pRange = aSels.First(); + while ( pRange ) + { + delete pRange; + pRange = aSels.Next(); + } +} + +// ----------------------------------------------------------------------- + +MultiSelection& MultiSelection::operator= ( const MultiSelection& rOrig ) +{ + aTotRange = rOrig.aTotRange; + bCurValid = rOrig.bCurValid; + if ( bCurValid ) + { + nCurSubSel = rOrig.nCurSubSel; + nCurIndex = rOrig.nCurIndex; + } + + // clear the old and copy the sub selections + ImplClear(); + for ( ULONG n = 0; n < rOrig.aSels.Count(); ++n ) + aSels.Insert( new Range( *rOrig.aSels.GetObject(n) ), LIST_APPEND ); + nSelCount = rOrig.nSelCount; + + return *this; +} + +// ----------------------------------------------------------------------- + +BOOL MultiSelection::operator== ( MultiSelection& rWith ) +{ + if ( aTotRange != rWith.aTotRange || nSelCount != rWith.nSelCount || + aSels.Count() != rWith.aSels.Count() ) + return FALSE; + + // compare the sub seletions + for ( ULONG n = 0; n < aSels.Count(); ++n ) + if ( *aSels.GetObject(n) != *rWith.aSels.GetObject(n) ) + return FALSE; + return TRUE; +} + +// ----------------------------------------------------------------------- + +void MultiSelection::SelectAll( BOOL bSelect ) +{ + DBG(DbgOutf( "::SelectAll(%s)\n", bSelect ? "TRUE" : "FALSE" )); + + ImplClear(); + if ( bSelect ) + { + aSels.Insert( new Range(aTotRange), LIST_APPEND ); + nSelCount = aTotRange.Len(); + } + + DBG(Print( this )); +} + +// ----------------------------------------------------------------------- + +BOOL MultiSelection::Select( long nIndex, BOOL bSelect ) +{ + DBG_ASSERT( aTotRange.IsInside(nIndex), "selected index out of range" ); + + // out of range? + if ( !aTotRange.IsInside(nIndex) ) + return FALSE; + + // find the virtual target position + ULONG nSubSelPos = ImplFindSubSelection( nIndex ); + + if ( bSelect ) + { + // is it included in the found sub selection? + if ( nSubSelPos < aSels.Count() && + aSels.GetObject(nSubSelPos)->IsInside( nIndex ) ) + // already selected, nothing to do + return FALSE; + + // it will become selected + ++nSelCount; + + // is it at the end of the previous sub selection + if ( nSubSelPos > 0 && + aSels.GetObject(nSubSelPos-1)->Max() == (nIndex-1) ) + { + // expand the previous sub selection + aSels.GetObject(nSubSelPos-1)->Max() = nIndex; + + // try to merge the previous sub selection + ImplMergeSubSelections( nSubSelPos-1, nSubSelPos ); + } + // is is at the beginning of the found sub selection + else if ( nSubSelPos < aSels.Count() && + aSels.GetObject(nSubSelPos)->Min() == (nIndex+1) ) + // expand the found sub selection + aSels.GetObject(nSubSelPos)->Min() = nIndex; + else + { + // create a new sub selection + aSels.Insert( new Range( nIndex, nIndex ), nSubSelPos ); + if ( bCurValid && nCurSubSel >= nSubSelPos ) + ++nCurSubSel; + } + } + else + { + // is it excluded from the found sub selection? + if ( nSubSelPos >= aSels.Count() || + !aSels.GetObject(nSubSelPos)->IsInside( nIndex ) ) + { + // not selected, nothing to do + DBG(Print( this )); + return FALSE; + } + + // it will become deselected + --nSelCount; + + // is it the only index in the found sub selection? + if ( aSels.GetObject(nSubSelPos)->Len() == 1 ) + { + // remove the complete sub selection + delete aSels.Remove( nSubSelPos ); + DBG(Print( this )); + return TRUE; + } + + // is it at the beginning of the found sub selection? + if ( aSels.GetObject(nSubSelPos)->Min() == nIndex ) + ++aSels.GetObject(nSubSelPos)->Min(); + // is it at the end of the found sub selection? + else if ( aSels.GetObject(nSubSelPos)->Max() == nIndex ) + --aSels.GetObject(nSubSelPos)->Max(); + // it is in the middle of the found sub selection? + else + { + // split the sub selection + aSels.Insert( + new Range( aSels.GetObject(nSubSelPos)->Min(), nIndex-1 ), + nSubSelPos ); + aSels.GetObject(nSubSelPos+1)->Min() = nIndex + 1; + } + } + + DBG(Print( this )); + + return TRUE; +} + +// ----------------------------------------------------------------------- + +void MultiSelection::Select( const Range& rIndexRange, BOOL bSelect ) +{ + Range* pRange; + long nOld; + + ULONG nTmpMin = rIndexRange.Min(); + ULONG nTmpMax = rIndexRange.Max(); + ULONG nCurMin = FirstSelected(); + ULONG nCurMax = LastSelected(); + DBG_ASSERT(aTotRange.IsInside(nTmpMax), "selected index out of range" ); + DBG_ASSERT(aTotRange.IsInside(nTmpMin), "selected index out of range" ); + + // gesamte Selektion ersetzen ? + if( nTmpMin <= nCurMin && nTmpMax >= nCurMax ) + { + ImplClear(); + if ( bSelect ) + { + aSels.Insert( new Range(rIndexRange), LIST_APPEND ); + nSelCount = rIndexRange.Len(); + } + return; + } + // links erweitern ? + if( nTmpMax < nCurMin ) + { + if( bSelect ) + { + // ersten Range erweitern ? + if( nCurMin > (nTmpMax+1) ) + { + pRange = new Range( rIndexRange ); + aSels.Insert( pRange, (ULONG)0 ); + nSelCount += pRange->Len(); + } + else + { + pRange = aSels.First(); + nOld = pRange->Min(); + pRange->Min() = (long)nTmpMin; + nSelCount += ( nOld - nTmpMin ); + } + bCurValid = FALSE; + } + return; + } + // rechts erweitern ? + else if( nTmpMin > nCurMax ) + { + if( bSelect ) + { + // letzten Range erweitern ? + if( nTmpMin > (nCurMax+1) ) + { + pRange = new Range( rIndexRange ); + aSels.Insert( pRange, LIST_APPEND ); + nSelCount += pRange->Len(); + } + else + { + pRange = aSels.Last(); + nOld = pRange->Max(); + pRange->Max() = (long)nTmpMax; + nSelCount += ( nTmpMax - nOld ); + } + bCurValid = FALSE; + } + return; + } + + //HACK(Hier muss noch optimiert werden) + while( nTmpMin <= nTmpMax ) + { + Select( nTmpMin, bSelect ); + nTmpMin++; + } +} + +// ----------------------------------------------------------------------- + +BOOL MultiSelection::IsSelected( long nIndex ) const +{ + // find the virtual target position + ULONG nSubSelPos = ImplFindSubSelection( nIndex ); + + return nSubSelPos < aSels.Count() && + aSels.GetObject(nSubSelPos)->IsInside(nIndex); +} + +// ----------------------------------------------------------------------- + +void MultiSelection::Insert( long nIndex, long nCount ) +{ + DBG(DbgOutf( "::Insert(%ld, %ld)\n", nIndex, nCount )); + + // find the virtual target position + ULONG nSubSelPos = ImplFindSubSelection( nIndex ); + + // did we need to shift the sub selections? + if ( nSubSelPos < aSels.Count() ) + { + // did we insert an unselected into an existing sub selection? + if ( !bSelectNew && aSels.GetObject(nSubSelPos)->Min() != nIndex && + aSels.GetObject(nSubSelPos)->IsInside(nIndex) ) + { + // split the sub selection + aSels.Insert( + new Range( aSels.GetObject(nSubSelPos)->Min(), nIndex-1 ), + nSubSelPos ); + ++nSubSelPos; + aSels.GetObject(nSubSelPos)->Min() = nIndex; + } + + // did we append an selected to an existing sub selection? + else if ( bSelectNew && nSubSelPos > 0 && + aSels.GetObject(nSubSelPos)->Max() == nIndex-1 ) + // expand the previous sub selection + aSels.GetObject(nSubSelPos-1)->Max() += nCount; + + // did we insert an selected into an existing sub selection? + else if ( bSelectNew && aSels.GetObject(nSubSelPos)->Min() == nIndex ) + { + // expand the sub selection + aSels.GetObject(nSubSelPos)->Max() += nCount; + ++nSubSelPos; + } + + // shift the sub selections behind the inserting position + for ( ULONG nPos = nSubSelPos; nPos < aSels.Count(); ++nPos ) + { + aSels.GetObject(nPos)->Min() += nCount; + aSels.GetObject(nPos)->Max() += nCount; + } + } + + bCurValid = FALSE; + aTotRange.Max() += nCount; + if ( bSelectNew ) + nSelCount += nCount; + + DBG(Print( this )); +} + +// ----------------------------------------------------------------------- + +void MultiSelection::Remove( long nIndex ) +{ + DBG(DbgOutf( "::Remove(%ld)\n", nIndex )); + + // find the virtual target position + ULONG nSubSelPos = ImplFindSubSelection( nIndex ); + + // did we remove from an existing sub selection? + if ( nSubSelPos < aSels.Count() && + aSels.GetObject(nSubSelPos)->IsInside(nIndex) ) + { + // does this sub selection only contain the index to be deleted + if ( aSels.GetObject(nSubSelPos)->Len() == 1 ) + // completely remove the sub selection + aSels.Remove(nSubSelPos); + else + // shorten this sub selection + --( aSels.GetObject(nSubSelPos++)->Max() ); + + // adjust the selected counter + --nSelCount; + } + + // shift the sub selections behind the removed index + for ( ULONG nPos = nSubSelPos; nPos < aSels.Count(); ++nPos ) + { + --( aSels.GetObject(nPos)->Min() ); + --( aSels.GetObject(nPos)->Max() ); + } + + bCurValid = FALSE; + aTotRange.Max() -= 1; + + DBG(Print( this )); +} + +// ----------------------------------------------------------------------- + +void MultiSelection::Append( long nCount ) +{ + long nPrevLast = aTotRange.Max(); + aTotRange.Max() += nCount; + if ( bSelectNew ) + { + nSelCount += nCount; + aSels.Insert( new Range( nPrevLast+1, nPrevLast + nCount ), + LIST_APPEND ); + if ( aSels.Count() > 1 ) + ImplMergeSubSelections( aSels.Count() - 2, aSels.Count() ); + } +} + +// ----------------------------------------------------------------------- + +long MultiSelection::ImplFwdUnselected() +{ + if ( !bCurValid ) + return SFX_ENDOFSELECTION; + + if ( ( nCurSubSel < aSels.Count() ) && + ( aSels.GetObject(nCurSubSel)->Min() <= nCurIndex ) ) + nCurIndex = aSels.GetObject(nCurSubSel++)->Max() + 1; + + if ( nCurIndex <= aTotRange.Max() ) + return nCurIndex; + else + return SFX_ENDOFSELECTION; +} + +// ----------------------------------------------------------------------- + +long MultiSelection::ImplBwdUnselected() +{ + if ( !bCurValid ) + return SFX_ENDOFSELECTION; + + if ( aSels.GetObject(nCurSubSel)->Max() < nCurIndex ) + return nCurIndex; + + nCurIndex = aSels.GetObject(nCurSubSel--)->Min() - 1; + if ( nCurIndex >= 0 ) + return nCurIndex; + else + return SFX_ENDOFSELECTION; +} + +// ----------------------------------------------------------------------- + +long MultiSelection::FirstSelected( BOOL bInverse ) +{ + bInverseCur = bInverse; + nCurSubSel = 0; + + if ( bInverseCur ) + { + bCurValid = nSelCount < ULONG(aTotRange.Len()); + if ( bCurValid ) + { + nCurIndex = 0; + return ImplFwdUnselected(); + } + } + else + { + bCurValid = aSels.Count() > 0; + if ( bCurValid ) + return nCurIndex = aSels.GetObject(0)->Min(); + } + + return SFX_ENDOFSELECTION; +} + +// ----------------------------------------------------------------------- + +long MultiSelection::LastSelected( BOOL bInverse ) +{ + nCurSubSel = aSels.Count() - 1; + bCurValid = aSels.Count() > 0; + + if ( bCurValid ) + return nCurIndex = aSels.GetObject(nCurSubSel)->Max(); + + return SFX_ENDOFSELECTION; +} + +// ----------------------------------------------------------------------- + +long MultiSelection::NextSelected() +{ + if ( !bCurValid ) + return SFX_ENDOFSELECTION; + + if ( bInverseCur ) + { + ++nCurIndex; + return ImplFwdUnselected(); + } + else + { + // is the next index in the current sub selection too? + if ( nCurIndex < aSels.GetObject(nCurSubSel)->Max() ) + return ++nCurIndex; + + // are there further sub selections? + if ( ++nCurSubSel < aSels.Count() ) + return nCurIndex = aSels.GetObject(nCurSubSel)->Min(); + + // we are at the end! + return SFX_ENDOFSELECTION; + } +} + +// ----------------------------------------------------------------------- + +long MultiSelection::PrevSelected() +{ + if ( !bCurValid ) + return SFX_ENDOFSELECTION; + + if ( bInverseCur ) + { + --nCurIndex; + return ImplBwdUnselected(); + } + else + { + // is the previous index in the current sub selection too? + if ( nCurIndex > aSels.GetObject(nCurSubSel)->Min() ) + return --nCurIndex; + + // are there previous sub selections? + if ( nCurSubSel > 0 ) + { + --nCurSubSel; + return nCurIndex = aSels.GetObject(nCurSubSel)->Max(); + } + + // we are at the beginning! + return SFX_ENDOFSELECTION; + } +} + +// ----------------------------------------------------------------------- + +void MultiSelection::SetTotalRange( const Range& rTotRange ) +{ + aTotRange = rTotRange; + + // die untere Bereichsgrenze anpassen + Range* pRange = aSels.GetObject( 0 ); + while( pRange ) + { + if( pRange->Max() < aTotRange.Min() ) + { + delete pRange; + aSels.Remove( (ULONG)0 ); + } + else if( pRange->Min() < aTotRange.Min() ) + { + pRange->Min() = aTotRange.Min(); + break; + } + else + break; + + pRange = aSels.GetObject( 0 ); + } + + // die obere Bereichsgrenze anpassen + ULONG nCount = aSels.Count(); + while( nCount ) + { + pRange = aSels.GetObject( nCount - 1 ); + if( pRange->Min() > aTotRange.Max() ) + { + delete pRange; + aSels.Remove( (ULONG)(nCount - 1) ); + } + else if( pRange->Max() > aTotRange.Max() ) + { + pRange->Max() = aTotRange.Max(); + break; + } + else + break; + + nCount = aSels.Count(); + } + + // Selection-Count neu berechnen + nSelCount = 0; + pRange = aSels.First(); + while( pRange ) + { + nSelCount += pRange->Len(); + pRange = aSels.Next(); + } + + bCurValid = FALSE; + nCurIndex = 0; +} diff --git a/tools/source/memtools/table.cxx b/tools/source/memtools/table.cxx new file mode 100644 index 000000000000..d84676f2c052 --- /dev/null +++ b/tools/source/memtools/table.cxx @@ -0,0 +1,442 @@ +/************************************************************************* + * + * $RCSfile: table.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _TOOLS_TABLE_CXX + +// ----------------------------------------------------------------------- + +#define protected public + +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _IMPCONT_HXX +#include <impcont.hxx> +#endif +#ifndef _TOOLS_TABLE_HXX +#include <table.hxx> +#endif + +// ======================================================================= + +ULONG Table::ImplGetIndex( ULONG nKey, ULONG* pIndex ) const +{ + // Abpruefen, ob der erste Key groesser als der Vergleichskey ist + if ( !nCount || (nKey < (ULONG)Container::ImpGetObject(0)) ) + return TABLE_ENTRY_NOTFOUND; + + ULONG nLow; + ULONG nHigh; + ULONG nMid; + ULONG nCompareKey; + void** pNodes = Container::ImpGetOnlyNodes(); + + // Binaeres Suchen + nLow = 0; + nHigh = nCount-1; + if ( pNodes ) + { + do + { + nMid = (nLow + nHigh) / 2; + nCompareKey = (ULONG)pNodes[nMid*2]; + if ( nKey < nCompareKey ) + nHigh = nMid-1; + else + { + if ( nKey > nCompareKey ) + nLow = nMid + 1; + else + return nMid*2; + } + } + while ( nLow <= nHigh ); + } + else + { + do + { + nMid = (nLow + nHigh) / 2; + nCompareKey = (ULONG)Container::ImpGetObject( nMid*2 ); + if ( nKey < nCompareKey ) + nHigh = nMid-1; + else + { + if ( nKey > nCompareKey ) + nLow = nMid + 1; + else + return nMid*2; + } + } + while ( nLow <= nHigh ); + } + + if ( pIndex ) + { + if ( nKey > nCompareKey ) + *pIndex = (nMid+1)*2; + else + *pIndex = nMid*2; + } + + return TABLE_ENTRY_NOTFOUND; +} + +// ======================================================================= + +Table::Table( USHORT _nInitSize, USHORT _nReSize ) : + Container( CONTAINER_MAXBLOCKSIZE, _nInitSize*2, _nReSize*2 ) +{ + DBG_ASSERT( _nInitSize <= 32767, "Table::Table(): InitSize > 32767" ); + DBG_ASSERT( _nReSize <= 32767, "Table::Table(): ReSize > 32767" ); + nCount = 0; +} + +// ----------------------------------------------------------------------- + +BOOL Table::Insert( ULONG nKey, void* p ) +{ + // Tabellenelement einsortieren + ULONG i; + if ( nCount ) + { + if ( nCount <= 24 ) + { + USHORT n = 0; + USHORT nTempCount = (USHORT)nCount * 2; + void** pNodes = Container::ImpGetOnlyNodes(); + ULONG nCompareKey = (ULONG)(*pNodes); + while ( nKey > nCompareKey ) + { + n += 2; + pNodes += 2; + if ( n < nTempCount ) + nCompareKey = (ULONG)(*pNodes); + else + { + nCompareKey = 0; + break; + } + } + + // Testen, ob sich der Key schon in der Tabelle befindet + if ( nKey == nCompareKey ) + return FALSE; + + i = n; + } + else + { + i = 0; + if ( ImplGetIndex( nKey, &i ) != TABLE_ENTRY_NOTFOUND ) + return FALSE; + } + } + else + i = 0; + + // Eintrag einfuegen (Key vor Pointer) + Container::Insert( (void*)nKey, i ); + Container::Insert( p, i+1 ); + + // Ein neuer Eintrag + nCount++; + + return TRUE; +} + +// ----------------------------------------------------------------------- + +void* Table::Remove( ULONG nKey ) +{ + // Index besorgen + ULONG nIndex = ImplGetIndex( nKey ); + + // Testen, ob sich der Key in der Tabelle befindet + if ( nIndex == TABLE_ENTRY_NOTFOUND ) + return NULL; + + // Itemanzahl erniedrigen + nCount--; + + // Key entfernen + Container::Remove( nIndex ); + + // Pointer entfernen und zurueckgeben + return Container::Remove( nIndex ); +} + +// ----------------------------------------------------------------------- + +void* Table::Replace( ULONG nKey, void* p ) +{ + // Index abfragen + ULONG nIndex = ImplGetIndex( nKey ); + + // Existiert kein Eintrag mit dem Schluessel + if ( nIndex == TABLE_ENTRY_NOTFOUND ) + return NULL; + else + return Container::Replace( p, nIndex+1 ); +} + +// ----------------------------------------------------------------------- + +void* Table::Get( ULONG nKey ) const +{ + // Index besorgen + ULONG nIndex = ImplGetIndex( nKey ); + + // Testen, ob sich der Key in der Tabelle befindet + if ( nIndex == TABLE_ENTRY_NOTFOUND ) + return NULL; + else + return Container::ImpGetObject( nIndex+1 ); +} + +// ----------------------------------------------------------------------- + +void* Table::GetCurObject() const +{ + return Container::ImpGetObject( Container::GetCurPos()+1 ); +} + +// ----------------------------------------------------------------------- + +ULONG Table::GetKey( const void* p ) const +{ + ULONG nIndex = 0; + + // Solange noch Eintraege Vorhanden sind + while ( nIndex < nCount ) + { + // Stimmt der Pointer ueberein, wird der Key zurueckgegeben + if ( p == Container::ImpGetObject( (nIndex*2)+1 ) ) + return (ULONG)Container::ImpGetObject( nIndex*2 ); + + nIndex++; + } + + return TABLE_ENTRY_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +BOOL Table::IsKeyValid( ULONG nKey ) const +{ + return (ImplGetIndex( nKey ) != TABLE_ENTRY_NOTFOUND) ? TRUE : FALSE; +} + +// ----------------------------------------------------------------------- + +ULONG Table::GetUniqueKey( ULONG nStartKey ) const +{ + DBG_ASSERT( (nStartKey > 1) && (nStartKey < 0xFFFFFFFF), + "Table::GetUniqueKey() - nStartKey == 0 or nStartKey >= 0xFFFFFFFF" ); + + if ( !nCount ) + return nStartKey; + + ULONG nLastKey = (ULONG)Container::GetObject( (nCount*2)-2 ); + if ( nLastKey < nStartKey ) + return nStartKey; + else + { + if ( nLastKey < 0xFFFFFFFE ) + return nLastKey+1; + else + { + ULONG nPos; + ULONG nTempPos = ImplGetIndex( nStartKey, &nPos ); + if ( nTempPos != TABLE_ENTRY_NOTFOUND ) + nPos = nTempPos; + nLastKey = (ULONG)Container::GetObject( nPos ); + if ( nStartKey < nLastKey ) + return nStartKey; + while ( nLastKey < 0xFFFFFFFE ) + { + nPos += 2; + nLastKey++; + if ( nLastKey != (ULONG)Container::GetObject( nPos ) ) + return nLastKey; + } + } + } + + return 0; +} + +// ----------------------------------------------------------------------- + +ULONG Table::SearchKey( ULONG nKey, ULONG* pPos ) const +{ + *pPos = 0; + ULONG nPos = ImplGetIndex( nKey, pPos ); + if ( nPos != TABLE_ENTRY_NOTFOUND ) + { + nPos /= 2; + *pPos = nPos; + } + else + *pPos /= 2; + return nPos; +} + +// ----------------------------------------------------------------------- + +void* Table::Seek( ULONG nKey ) +{ + // Testen, ob ein Eintrag vorhanden ist + if ( nCount ) + { + ULONG nIndex = ImplGetIndex( nKey ); + + // Ist Key nicht enthalten + if ( nIndex == TABLE_ENTRY_NOTFOUND ) + return NULL; + else + { + // Index setzen + Container::Seek( nIndex ); + + // Pointer zurueckgeben + return Container::ImpGetObject( Container::GetCurPos() + 1 ); + } + } + else + return NULL; +} + +// ----------------------------------------------------------------------- + +void* Table::Seek( void* p ) +{ + ULONG nKey = GetKey( p ); + + // Ist Key vorhanden, dann als aktuellen Eintrag setzen + if ( nKey != TABLE_ENTRY_NOTFOUND ) + return Seek( nKey ); + else + return NULL; +} + +// ----------------------------------------------------------------------- + +void* Table::First() +{ + // Testen, ob ein Eintrag vorhanden ist + if ( nCount ) + { + // Auf ersten Eintag setzen + Container::First(); + + // Pointer zurueckgeben + return Container::ImpGetObject( 1 ); + } + else + return NULL; +} + +// ----------------------------------------------------------------------- + +void* Table::Last() +{ + // Testen, ob ein Eintrag vorhanden ist + if ( nCount ) + { + // Last auf letzten Eintrag setzen + void* p = Container::Last(); + Container::Prev(); + + // Pointer zurueckgeben + return p; + } + else + return NULL; +} + +// ----------------------------------------------------------------------- + +void* Table::Next() +{ + // Ueber den Pointer weiterschalten + Container::Next(); + + // Nachsten Eintag + Container::Next(); + + // Pointer vom naechsten Key zurueckgeben + return Container::ImpGetObject( Container::GetCurPos() + 1 ); +} + +// ----------------------------------------------------------------------- + +void* Table::Prev() +{ + // Ueber den Pointer weiterschalten + void* p = Container::Prev(); + + // Nachsten Eintag + Container::Prev(); + + // Pointer vom vorherigen Key zurueckgeben + return p; +} diff --git a/tools/source/memtools/unqidx.cxx b/tools/source/memtools/unqidx.cxx new file mode 100644 index 000000000000..435e5fc117be --- /dev/null +++ b/tools/source/memtools/unqidx.cxx @@ -0,0 +1,643 @@ +/************************************************************************* + * + * $RCSfile: unqidx.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define protected public + +#ifndef _IMPCONT_HXX +#include <impcont.hxx> +#endif + +#ifndef _UNQIDX_HXX +#include <unqidx.hxx> +#endif + +#ifndef _UNQID_HXX +#include <unqid.hxx> +#endif + +/************************************************************************* +|* +|* UniqueIndex::UniqueIndex() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +UniqueIndex::UniqueIndex( ULONG _nStartIndex, + ULONG _nInitSize, ULONG _nReSize ) : + Container( _nInitSize ) +{ + nReSize = _nReSize; + nStartIndex = _nStartIndex; + nUniqIndex = 0; + nCount = 0; +} + +/************************************************************************* +|* +|* UniqueIndex::UniqueIndex() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +UniqueIndex::UniqueIndex( const UniqueIndex& rIdx ) : + Container( rIdx ) +{ + nReSize = rIdx.nReSize; + nStartIndex = rIdx.nStartIndex; + nUniqIndex = rIdx.nUniqIndex; + nCount = rIdx.nCount; +} + +/************************************************************************* +|* +|* UniqueIndex::Insert() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +ULONG UniqueIndex::Insert( void* p ) +{ + // NULL-Pointer ist nicht erlaubt + if ( !p ) + return UNIQUEINDEX_ENTRY_NOTFOUND; + + // Ist Array voll, dann expandieren + if ( nCount == Container::GetSize() ) + SetSize( nCount + nReSize ); + + // Damit UniqIndex nicht ueberlaeuft, wenn Items geloescht wurden + nUniqIndex = nUniqIndex % Container::GetSize(); + + // Leeren Eintrag suchen + while ( Container::ImpGetObject( nUniqIndex ) != NULL ) + nUniqIndex = (nUniqIndex+1) % Container::GetSize(); + + // Object im Array speichern + Container::Replace( p, nUniqIndex ); + + // Anzahl der Eintraege erhoehen und Index zurueckgeben + nCount++; + nUniqIndex++; + return ( nUniqIndex + nStartIndex - 1 ); +} + +/************************************************************************* +|* +|* UniqueIndex::Insert() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 21.04.96 +|* Letzte Aenderung MM 21.04.96 +|* +*************************************************************************/ + +ULONG UniqueIndex::Insert( ULONG nIndex, void* p ) +{ + // NULL-Pointer ist nicht erlaubt + if ( !p ) + return UNIQUEINDEX_ENTRY_NOTFOUND; + + ULONG nContIndex = nIndex - nStartIndex; + // Ist Array voll, dann expandieren + if ( nContIndex >= Container::GetSize() ) + SetSize( nContIndex + nReSize ); + + // Object im Array speichern + Container::Replace( p, nContIndex ); + + // Anzahl der Eintraege erhoehen und Index zurueckgeben + nCount++; + return nIndex; +} + +/************************************************************************* +|* +|* UniqueIndex::Remove() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Remove( ULONG nIndex ) +{ + // Ist Index zulaessig + if ( (nIndex >= nStartIndex) && + (nIndex < (Container::GetSize()+nStartIndex)) ) + { + // Index-Eintrag als leeren Eintrag setzen und Anzahl der + // gespeicherten Indexe erniedriegen, wenn Eintrag belegt war + void* p = Container::Replace( NULL, nIndex-nStartIndex ); + if ( p ) + nCount--; + return p; + } + else + return NULL; +} + +/************************************************************************* +|* +|* UniqueIndex::Replace() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Replace( ULONG nIndex, void* p ) +{ + // NULL-Pointer ist nicht erlaubt + if ( !p ) + return NULL; + + // Ist Index zulaessig + if ( IsIndexValid( nIndex ) ) + { + // Index-Eintrag ersetzen und alten zurueckgeben + return Container::Replace( p, nIndex-nStartIndex ); + } + else + return NULL; +} + +/************************************************************************* +|* +|* UniqueIndex::Get() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Get( ULONG nIndex ) const +{ + // Ist Index zulaessig + if ( (nIndex >= nStartIndex) && + (nIndex < (Container::GetSize()+nStartIndex)) ) + return Container::ImpGetObject( nIndex-nStartIndex ); + else + return NULL; +} + +/************************************************************************* +|* +|* UniqueIndex::GetCurIndex() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +ULONG UniqueIndex::GetCurIndex() const +{ + ULONG nPos = Container::GetCurPos(); + + // Ist der Current-Index nicht belegt, dann gibt es keinen Current-Index + if ( !Container::ImpGetObject( nPos ) ) + return UNIQUEINDEX_ENTRY_NOTFOUND; + else + return nPos+nStartIndex; +} + +/************************************************************************* +|* +|* UniqueIndex::GetIndex() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +ULONG UniqueIndex::GetIndex( const void* p ) const +{ + // Wird ein NULL-Pointer uebergeben, dann wurde Pointer nicht gefunden + if ( !p ) + return UNIQUEINDEX_ENTRY_NOTFOUND; + + ULONG nIndex = Container::GetPos( p ); + + if ( nIndex != CONTAINER_ENTRY_NOTFOUND ) + return nIndex+nStartIndex; + else + return UNIQUEINDEX_ENTRY_NOTFOUND; +} + +/************************************************************************* +|* +|* UniqueIndex::IsIndexValid() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +BOOL UniqueIndex::IsIndexValid( ULONG nIndex ) const +{ + // Ist Index zulaessig + if ( (nIndex >= nStartIndex) && + (nIndex < (Container::GetSize()+nStartIndex)) ) + { + // Index ist nur zulaessig, wenn Eintrag auch belegt ist + if ( Container::ImpGetObject( nIndex-nStartIndex ) ) + return TRUE; + else + return FALSE; + } + else + return FALSE; +} + +/************************************************************************* +|* +|* UniqueIndex::Seek() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Seek( ULONG nIndex ) +{ + // Index-Eintrag als aktuellen setzten, wenn er gueltig ist + if ( IsIndexValid( nIndex ) ) + return Container::Seek( nIndex-nStartIndex ); + else + return NULL; +} + +/************************************************************************* +|* +|* UniqueIndex::Seek() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Seek( void* p ) +{ + // Wird ein NULL-Pointer uebergeben, dann wurde Pointer nicht gefunden + if ( !p ) + return NULL; + + ULONG nIndex = GetIndex( p ); + + // Ist Index vorhanden, dann als aktuellen Eintrag setzen + if ( nIndex != UNIQUEINDEX_ENTRY_NOTFOUND ) + return Container::Seek( nIndex-nStartIndex ); + else + return NULL; +} + +/************************************************************************* +|* +|* UniqueIndex::First() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::First() +{ + void* p = Container::First(); + + while ( !p && (Container::GetCurPos() < (Container::GetSize()-1)) ) + p = Container::Next(); + + return p; +} + +/************************************************************************* +|* +|* UniqueIndex::Last() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Last() +{ + void* p = Container::Last(); + + while ( !p && Container::GetCurPos() ) + p = Container::Prev(); + + return p; +} + +/************************************************************************* +|* +|* UniqueIndex::Next() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Next() +{ + void* p = NULL; + + while ( !p && (Container::GetCurPos() < (Container::GetSize()-1)) ) + p = Container::Next(); + + return p; +} + +/************************************************************************* +|* +|* UniqueIndex::Prev() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +void* UniqueIndex::Prev() +{ + void* p = NULL; + + while ( !p && Container::GetCurPos() ) + p = Container::Prev(); + + return p; +} + +/************************************************************************* +|* +|* UniqueIndex::operator =() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +UniqueIndex& UniqueIndex::operator =( const UniqueIndex& rIdx ) +{ + // Neue Werte zuweisen + Container::operator =( rIdx ); + nReSize = rIdx.nReSize; + nStartIndex = rIdx.nStartIndex; + nUniqIndex = rIdx.nUniqIndex; + nCount = rIdx.nCount; + return *this; +} + +/************************************************************************* +|* +|* UniqueIndex::operator ==() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung TH 24.09.91 +|* Letzte Aenderung TH 24.09.91 +|* +*************************************************************************/ + +BOOL UniqueIndex::operator ==( const UniqueIndex& rIdx ) const +{ + // Neue Werte zuweisen + if ( (nStartIndex == rIdx.nStartIndex) && + (nCount == rIdx.nCount) && + (Container::operator ==( rIdx )) ) + return TRUE; + else + return FALSE; +} +/************************************************************************* +|* +|* UniqueIdContainer::UniqueIdContainer () +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 29.04.96 +|* Letzte Aenderung MM 29.04.96 +|* +*************************************************************************/ + +UniqueIdContainer::UniqueIdContainer( const UniqueIdContainer& rObj ) + : UniqueIndex( rObj ) + , nCollectCount( rObj.nCollectCount ) +{ + ULONG nCur = GetCurIndex(); + + ImpUniqueId * pEle = (ImpUniqueId *)First(); + while( pEle ) + { + pEle->nRefCount++; + pEle = (ImpUniqueId *)Next(); + } + Seek( nCur ); +} + +/************************************************************************* +|* +|* UniqueIdContainer::operator = () +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 01.08.94 +|* Letzte Aenderung MM 01.08.94 +|* +*************************************************************************/ + +UniqueIdContainer& UniqueIdContainer::operator = ( const UniqueIdContainer & rObj ) +{ + UniqueIndex::operator = ( rObj ); + nCollectCount = rObj.nCollectCount; + + ULONG nCur = GetCurIndex(); + + ImpUniqueId * pEle = (ImpUniqueId *)First(); + while( pEle ) + { + pEle->nRefCount++; + pEle = (ImpUniqueId *)Next(); + } + Seek( nCur ); + return *this; +} + +/************************************************************************* +|* +|* UniqueIdContainer::Clear() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 01.08.94 +|* Letzte Aenderung MM 01.08.94 +|* +*************************************************************************/ + +void UniqueIdContainer::Clear( BOOL bAll ) +{ + USHORT nFree = bAll ? 0xFFFF : 1; + + ImpUniqueId* pId = (ImpUniqueId*)Last(); + BOOL bLast = TRUE; + while ( pId ) + { + if ( pId->nRefCount <= nFree ) + { + ((ImpUniqueId *)Remove( pId->nId ))->Release(); + if( bLast ) + pId = (ImpUniqueId *)Last(); + else + pId = (ImpUniqueId *)Prev(); + } + else + { + pId = (ImpUniqueId *)Prev(); + bLast = FALSE; + } + } +} + +/************************************************************************* +|* +|* UniqueIdContainer::CreateId() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 01.08.94 +|* Letzte Aenderung MM 01.08.94 +|* +*************************************************************************/ + +UniqueItemId UniqueIdContainer::CreateId() +{ + if( nCollectCount > 50 ) + { // aufraeumen + Clear( FALSE ); + nCollectCount = 0; + } + nCollectCount++; + + ImpUniqueId * pId = new ImpUniqueId; + pId->nRefCount = 1; + pId->nId = Insert( pId ); + return UniqueItemId( pId ); +} + +/************************************************************************* +|* +|* UniqueIdContainer::CreateIdProt() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 01.08.94 +|* Letzte Aenderung MM 01.08.94 +|* +*************************************************************************/ + +UniqueItemId UniqueIdContainer::CreateFreeId( ULONG nId ) +{ + // Einfach erzeugen, fuer abgeleitete Klasse + ImpUniqueId * pId = new ImpUniqueId; + pId->nRefCount = 0; + pId->nId = nId; + return UniqueItemId( pId ); +} + +/************************************************************************* +|* +|* UniqueIdContainer::CreateIdProt() +|* +|* Beschreibung UNQIDX.SDW +|* Ersterstellung MM 01.08.94 +|* Letzte Aenderung MM 01.08.94 +|* +*************************************************************************/ + +UniqueItemId UniqueIdContainer::CreateIdProt( ULONG nId ) +{ + if ( IsIndexValid( nId ) ) + return UniqueItemId( (ImpUniqueId *)Get( nId ) ); + + ImpUniqueId * pId; + do + { + pId = new ImpUniqueId; + pId->nRefCount = 1; + pId->nId = Insert( pId ); + } + while( pId->nId != nId ); + return UniqueItemId( pId ); +} diff --git a/tools/source/rc/makefile.mk b/tools/source/rc/makefile.mk new file mode 100644 index 000000000000..8aadfce6a2b0 --- /dev/null +++ b/tools/source/rc/makefile.mk @@ -0,0 +1,89 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=rc + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +CXXFILES= rc.cxx \ + resmgr.cxx + +SLOFILES= $(SLO)$/rc.obj \ + $(SLO)$/resmgr.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/rc.obj \ + $(OBJ)$/resmgr.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/rc/rc.cxx b/tools/source/rc/rc.cxx new file mode 100644 index 000000000000..daa5ffdb71d9 --- /dev/null +++ b/tools/source/rc/rc.cxx @@ -0,0 +1,311 @@ +/************************************************************************* + * + * $RCSfile: rc.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _TOOLS_RC_CXX + +#include <string.h> + +#ifndef _DATE_HXX +#include <date.hxx> +#endif +#ifndef _TIME_HXX +#include <time.hxx> +#endif +#ifndef _INTN_HXX +#include <intn.hxx> +#endif + +#ifndef _TOOLS_RC_HXX +#include <rc.hxx> +#endif +#ifndef _TOOLS_RCID_H +#include <rcid.h> +#endif + +#pragma hdrstop + +// ======================================================================= + +ImplSVResourceData aResData; + +inline ImplSVResourceData* GetResData() +{ + //return &ImplGetSVData()->maResourceData; + return &aResData; +} + +// ======================================================================= + +Resource::Resource( const ResId& rResId ) +{ + GetRes( rResId.SetRT( RSC_RESOURCE ) ); +} + +// ----------------------------------------------------------------------- + +void Resource::GetRes( const ResId& rResId ) +{ + if ( rResId.GetResMgr() ) + rResId.GetResMgr()->GetResource( rResId, this ); + else + GetResManager()->GetResource( rResId, this ); + + IncrementRes( sizeof( RSHEADER_TYPE ) ); +} + +// ----------------------------------------------------------------------- + +void Resource::TestRes() +{ + ImplSVResourceData* pSVInData = GetResData(); + if( pSVInData->pAppResMgr ) + GetResManager()->TestStack( this ); +} + +// ----------------------------------------------------------------------- + +void Resource::SetResManager( ResMgr* pNewResMgr ) +{ + ImplSVResourceData * pSVInData = GetResData(); + pSVInData->pAppResMgr = pNewResMgr; +} + +// ----------------------------------------------------------------------- + +ResMgr* Resource::GetResManager() +{ + ImplSVResourceData* pSVInData = GetResData(); + + return pSVInData->pAppResMgr; +} + +// ======================================================================= + +#ifndef ENABLEUNICODE + +String::String( const ResId& rResId ) +{ + rResId.SetRT( RSC_STRING ); + ResMgr* pResMgr = rResId.GetResMgr(); + if ( !pResMgr ) + pResMgr = Resource::GetResManager(); + + if ( pResMgr->GetResource( rResId ) ) + { + // String laden + RSHEADER_TYPE * pResHdr = (RSHEADER_TYPE*)pResMgr->GetClass(); + USHORT nLen = pResHdr->GetLocalOff() - sizeof( RSHEADER_TYPE ); + + USHORT nStringLen = strlen( (char*)(pResHdr+1) ); + UniString aWString( (const char*)(pResHdr+1), RTL_TEXTENCODING_UTF8, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT ); + InitStringRes( aWString ); + + USHORT nSize = sizeof( RSHEADER_TYPE ) + nStringLen + 1; + nSize += nSize % 2; + pResMgr->Increment( nSize ); + } +} + +#endif + +// ======================================================================= + +UniString::UniString( const ResId& rResId ) +{ + rResId.SetRT( RSC_STRING ); + ResMgr* pResMgr = rResId.GetResMgr(); + if ( !pResMgr ) + pResMgr = Resource::GetResManager(); + + if ( pResMgr->GetResource( rResId ) ) + { + // String laden + RSHEADER_TYPE * pResHdr = (RSHEADER_TYPE*)pResMgr->GetClass(); + USHORT nLen = pResHdr->GetLocalOff() - sizeof( RSHEADER_TYPE ); + + USHORT nStringLen = strlen( (char*)(pResHdr+1) ); + InitStringRes( (const char*)(pResHdr+1), nStringLen ); + + USHORT nSize = sizeof( RSHEADER_TYPE ) + nStringLen + 1; + nSize += nSize % 2; + pResMgr->Increment( nSize ); + } +} + +// ======================================================================= + +Time::Time( const ResId& rResId ) +{ + nTime = 0; + rResId.SetRT( RSC_TIME ); + ResMgr* pResMgr = NULL; + + ResMgr::GetResourceSkipHeader( rResId, &pResMgr ); + + USHORT nObjMask = (USHORT)pResMgr->ReadShort(); + + if ( 0x01 & nObjMask ) + SetHour( (USHORT)pResMgr->ReadShort() ); + if ( 0x02 & nObjMask ) + SetMin( (USHORT)pResMgr->ReadShort() ); + if ( 0x04 & nObjMask ) + SetSec( (USHORT)pResMgr->ReadShort() ); + if ( 0x08 & nObjMask ) + Set100Sec( (USHORT)pResMgr->ReadShort() ); +} + +// ======================================================================= + +Date::Date( const ResId& rResId ) +{ + rResId.SetRT( RSC_DATE ); + ResMgr* pResMgr = NULL; + + ResMgr::GetResourceSkipHeader( rResId, &pResMgr ); + + USHORT nObjMask = (USHORT)pResMgr->ReadShort(); + + if ( 0x01 & nObjMask ) + SetYear( (USHORT)pResMgr->ReadShort() ); + if ( 0x02 & nObjMask ) + SetMonth( (USHORT)pResMgr->ReadShort() ); + if ( 0x04 & nObjMask ) + SetDay( (USHORT)pResMgr->ReadShort() ); +} + +// ======================================================================= + +International::International( const ResId& rResId ) +{ + rResId.SetRT( RSC_INTERNATIONAL ); + ResMgr* pResMgr = NULL; + + ResMgr::GetResourceSkipHeader( rResId, &pResMgr ); + + USHORT nObjMask = (USHORT)pResMgr->ReadShort(); + + LanguageType eLangType = LANGUAGE_SYSTEM; + LanguageType eFormatType = LANGUAGE_SYSTEM; + + if ( 0x0001 & nObjMask ) + { + eLangType = (LanguageType)(USHORT)pResMgr->ReadShort(); + eFormatType = eLangType; + } + if ( 0x0002 & nObjMask ) + eFormatType = (LanguageType)(USHORT)pResMgr->ReadShort(); + Init( eLangType, eFormatType ); + + if ( 0x0004 & nObjMask ) + SetDateFormat( (DateFormat)(USHORT)pResMgr->ReadShort() ); + if ( 0x0008 & nObjMask ) + SetDateDayLeadingZero( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0010 & nObjMask ) + SetDateMonthLeadingZero( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0020 & nObjMask ) + SetDateCentury( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0040 & nObjMask ) + SetLongDateFormat( (DateFormat)(USHORT)pResMgr->ReadShort() ); + if ( 0x0080 & nObjMask ) + SetLongDateDayOfWeekFormat( (DayOfWeekFormat)(USHORT)pResMgr->ReadShort() ); + if ( 0x0100 & nObjMask ) + SetLongDateDayOfWeekSep( pResMgr->ReadString() ); + if ( 0x0200 & nObjMask ) + SetLongDateDayLeadingZero( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0400 & nObjMask ) + SetLongDateDaySep( pResMgr->ReadString() ); + if ( 0x0800 & nObjMask ) + SetLongDateMonthFormat( (MonthFormat)(USHORT)pResMgr->ReadShort() ); + if ( 0x1000 & nObjMask ) + SetLongDateMonthSep( pResMgr->ReadString() ); + if ( 0x2000 & nObjMask ) + SetLongDateCentury( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x4000 & nObjMask ) + SetLongDateYearSep( pResMgr->ReadString() ); + if ( 0x8000 & nObjMask ) + SetTimeFormat( (TimeFormat)(USHORT)pResMgr->ReadShort() ); + + // Zweite Maske holen + nObjMask = (USHORT)pResMgr->ReadShort(); + if ( 0x0001 & nObjMask ) + SetTimeLeadingZero( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0002 & nObjMask ) + SetTimeAM( pResMgr->ReadString() ); + if ( 0x0004 & nObjMask ) + SetTimePM( pResMgr->ReadString() ); + if ( 0x0008 & nObjMask ) + SetNumLeadingZero( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0010 & nObjMask ) + SetNumDigits( (USHORT)pResMgr->ReadShort() ); + if ( 0x0020 & nObjMask ) + SetCurrPositiveFormat( (USHORT)pResMgr->ReadShort() ); + if ( 0x0040 & nObjMask ) + SetCurrNegativeFormat( (USHORT)pResMgr->ReadShort() ); + if ( 0x0080 & nObjMask ) + SetCurrDigits( (USHORT)pResMgr->ReadShort() ); + if ( 0x0100 & nObjMask ) + SetNumTrailingZeros( (BOOL)(USHORT)pResMgr->ReadShort() ); + if ( 0x0200 & nObjMask ) + SetMeasurementSystem( (MeasurementSystem)(USHORT)pResMgr->ReadShort() ); +} diff --git a/tools/source/rc/resmgr.cxx b/tools/source/rc/resmgr.cxx new file mode 100644 index 000000000000..610f884b9b2b --- /dev/null +++ b/tools/source/rc/resmgr.cxx @@ -0,0 +1,1364 @@ +/************************************************************************* + * + * $RCSfile: resmgr.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:06 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + +#ifndef _VOS_SIGNAL_HXX_ +#include <vos/signal.hxx> +#endif + +#ifndef _NEW_HXX +#include <new.hxx> +#endif +#ifndef _DEBUG_HXX +#include <debug.hxx> +#endif +#ifndef _TABLE_HXX +#include <table.hxx> +#endif +#ifndef _FSYS_HXX +#include <fsys.hxx> +#endif +#ifndef _STREAM_HXX +#include <stream.hxx> +#endif +#ifndef _INTN_HXX +#include <intn.hxx> +#endif +#ifndef _TOOLS_RESMGR_HXX +#include <resmgr.hxx> +#endif +#ifndef _TOOLS_RC_HXX +#include <rc.hxx> +#endif +#ifndef _TOOLS_RCID_H +#include <rcid.h> +#endif + +#ifndef _TOOLS_SIMPLERESMGR_HXX_ +#include "simplerm.hxx" +#endif + +#pragma hdrstop + +// ======================================================================= + +extern ImplSVResourceData aResData; +inline ImplSVResourceData* GetResData() +{ + return &aResData; +} + +static List & GetResMgrList() +{ + ImplSVResourceData * pRD = GetResData(); + if ( !pRD->pInternalResMgrList ) + pRD->pInternalResMgrList = new List(); + return *pRD->pInternalResMgrList; +} + +struct ImpContent +{ + ULONG nTypeAndId; + ULONG nOffset; +}; + +#if defined( OS2 ) && defined( ICC ) +static int _Optlink Compare( const void * pFirst, const void * pSecond ) +#elif S390 +extern "C" { int Compare( const void * pFirst, const void * pSecond ) +#else +static int __LOADONCALLAPI Compare( const void * pFirst, const void * pSecond ) +#endif +{ + if( ((ImpContent *)pFirst)->nTypeAndId > ((ImpContent *)pSecond)->nTypeAndId ) + return( 1 ); + else if( ((ImpContent *)pFirst)->nTypeAndId < ((ImpContent *)pSecond)->nTypeAndId ) + return( -1 ); + else + return( 0 ); +} + +#ifdef S390 +} +#endif + +#if defined( OS2 ) && defined( ICC ) +static int _Optlink Search( const void * nTypeAndId, const void * pSecond ) +#elif S390 +extern "C" { int Search( const void * nTypeAndId, const void * pSecond ) +#else +static int __LOADONCALLAPI Search( const void * nTypeAndId, const void * pSecond ) +#endif +{ + if( (ULONG)nTypeAndId > (((ImpContent *)pSecond)->nTypeAndId) ) + return( 1 ); + else if( (ULONG)nTypeAndId < (((ImpContent *)pSecond)->nTypeAndId) ) + return( -1 ); + else + return( 0 ); +} + +#ifdef S390 +} +#endif + +// ======================================================================= + +SvStream * InternalResMgr::GetBitmapStream( USHORT nId ) +{ + // Anfang der Strings suchen + ImpContent * pFind = (ImpContent *) + bsearch( (void *)((ULONG(RT_SYS_BITMAP) << 16) | nId), pContent, nEntries, + sizeof( ImpContent ), Search ); + + if ( pFind ) + { + pStm->Seek( pFind->nOffset ); + return pStm; + } + return NULL; +} + +// ----------------------------------------------------------------------- + +void InternalResMgr::GetResMgrPath( InternalResMgr* pThis, + const UniString& rFileName, + const UniString* pAppFileName, + const UniString* pResourcePath ) +{ + UniString aResFile; + if ( rFileName.Len() ) + { + UniString aResPath; + if( pResourcePath ) + aResPath += *pResourcePath; + if ( pAppFileName ) + { + DirEntry aAppDir( *pAppFileName ); + aAppDir.CutName(); + UniString aAppPath = aAppDir.GetFull(); + DirEntry aResSubPath( UniString( RTL_CONSTASCII_USTRINGPARAM( "resource" ) ) ); + aAppDir += aResSubPath; + UniString aAppResPath = aAppDir.GetFull(); + + // Default resource path is bin\resource + if ( aResPath.Len() ) + aResPath += DirEntry::GetSearchDelimiter(); + aResPath += aAppResPath; + + // we a search also in the bin path + aResPath += DirEntry::GetSearchDelimiter(); + aResPath += aAppPath; + } + const sal_Char* pEnv = getenv( "STAR_RESOURCEPATH" ); + if( pEnv ) + { + if ( aResPath.Len() ) + aResPath += DirEntry::GetSearchDelimiter(); + aResPath.AppendAscii( pEnv ); + } + + DirEntry aFullName( rFileName ); + if ( aFullName.Find( aResPath ) ) + aResFile = aFullName.GetFull(); + else + aResFile = rFileName; + } + else if ( pAppFileName ) + { + // Default Resourcefile ist die Anwendung + aResFile = *pAppFileName; +#if defined( OS2 ) || defined( WIN ) || defined( WNT ) + aResFile.Erase( aResFile.Len() - 4 ); +#endif + aResFile.AppendAscii( ".res" ); + } + + if( aResFile.Len() ) + { + DirEntry aEntry = aResFile; + + FileStat aStat( aEntry ); + if( aStat.IsKind( FSYS_KIND_FILE ) ) + { + pThis->aFileName = aEntry.GetFull(); + pThis->aShortFileName = aEntry.GetName(); + } + } +} + +// ----------------------------------------------------------------------- + +InternalResMgr::InternalResMgr() + : pContent( NULL ) + , pStringBlock( NULL ) + , pStm( NULL ) + , bEqual2Content( TRUE ) + , nEntries( 0 ) + , pResUseDump( 0 ) +{ +} + +// ----------------------------------------------------------------------- + +InternalResMgr::~InternalResMgr() +{ + SvMemFree(pContent); + SvMemFree(pStringBlock); + delete pStm; + +#ifdef DBG_UTIL + if( pResUseDump ) + { + const sal_Char* pLogFile = getenv( "STAR_RESOURCE_LOGGING" ); + if ( pLogFile ) + { + SvFileStream aStm( UniString( pLogFile, RTL_TEXTENCODING_ASCII_US ), STREAM_WRITE ); + aStm.Seek( STREAM_SEEK_TO_END ); + ByteString aLine( "FileName: " ); + aLine.Append( ByteString( aFileName, RTL_TEXTENCODING_UTF8 ) ); + aStm.WriteLine( aLine ); + + for( ULONG i = 0; i < pResUseDump->Count(); i++ ) + { + ULONG nKeyId = pResUseDump->GetObjectKey( i ); + aLine.Assign( "Type/Id: " ); + aLine.Append( ByteString::CreateFromInt32( (nKeyId >> 16) & 0xFFFF ) ); + aLine.Append( '/' ); + aLine.Append( ByteString::CreateFromInt32( nKeyId & 0xFFFF ) ); + aStm.WriteLine( aLine ); + } + } + } +#endif + + delete pResUseDump; +} + +// ----------------------------------------------------------------------- + +InternalResMgr* InternalResMgr::Create( const UniString& rName, + const UniString* pAppName, + const UniString* pResPath ) +{ + InternalResMgr* pThis = new InternalResMgr(); + + GetResMgrPath( pThis, rName, pAppName, pResPath ); + + if ( pThis->aFileName.Len() && pThis->Create() ) + return pThis; + + delete pThis; + return NULL; +} + +// ----------------------------------------------------------------------- + +BOOL InternalResMgr::Create() +{ + BOOL bDone = FALSE; + + pStm = new SvFileStream( aFileName, (STREAM_READ | STREAM_SHARE_DENYWRITE | STREAM_NOCREATE) ); + if( pStm->GetError() == 0 ) + { + INT32 lContLen = 0; + + pStm->Seek( STREAM_SEEK_TO_END ); + /* + if( ( pInternalResMgr->pHead = (RSHEADER_TYPE *)mmap( 0, nResourceFileSize, + PROT_READ, MAP_PRIVATE, + fRes, 0 ) ) != (RSHEADER_TYPE *)-1) + */ + pStm->SeekRel( - (int)sizeof( lContLen ) ); + pStm->Read( &lContLen, sizeof( lContLen ) ); + // is bigendian, swab to the right endian + lContLen = ResMgr::GetLong( &lContLen ); + pStm->SeekRel( -lContLen ); + pContent = (ImpContent *)SvMemAlloc( lContLen ); + pStm->Read( pContent, lContLen ); + // Auf die Anzahl der ImpContent kürzen + nEntries = (UINT32)lContLen / sizeof( ImpContent ); + bEqual2Content = TRUE; // Die Daten der Resourcen liegen + // genauso wie das Inhaltsverzeichnis + BOOL bSorted = TRUE; + if( nEntries ) + { +#ifdef DBG_UTIL + const sal_Char* pLogFile = getenv( "STAR_RESOURCE_LOGGING" ); + if ( pLogFile ) + { + pResUseDump = new Table(); + for( ULONG i = 0; i < nEntries; i++ ) + pResUseDump->Insert( pContent[i].nTypeAndId, NULL ); + } +#endif + // swap the content to the right endian + pContent[0].nTypeAndId = ResMgr::GetLong( &pContent[0].nTypeAndId ); + pContent[0].nOffset = ResMgr::GetLong( &pContent[0].nOffset ); + for( ULONG i = 0; i < nEntries -1; i++ ) + { + // swap the content to the right endian + pContent[i+1].nTypeAndId = ResMgr::GetLong( &pContent[i+1].nTypeAndId ); + pContent[i+1].nOffset = ResMgr::GetLong( &pContent[i+1].nOffset ); + if( pContent[i].nTypeAndId >= pContent[i +1].nTypeAndId ) + bSorted = FALSE; + if( (pContent[i].nTypeAndId & 0xFFFF0000) == (pContent[i +1].nTypeAndId & 0xFFFF0000) + && pContent[i].nOffset >= pContent[i +1].nOffset ) + bEqual2Content = FALSE; + } + } + DBG_ASSERT( bSorted, "content not sorted" ) + DBG_ASSERT( bEqual2Content, "resource structure wrong" ) + if( !bSorted ) + qsort( pContent, nEntries, sizeof( ImpContent ), Compare ); + + bDone = TRUE; + } + + return bDone; +} + +// ----------------------------------------------------------------------- + +InternalResMgr* InternalResMgr::GetInternalResMgr( const UniString& rFileName, + const UniString* pAppName, + const UniString* pResPath ) +{ + ImplSVResourceData* pSVInData = GetResData(); + + // Nur InternalResMgr's mit FileNamen stehen in der Liste + if ( rFileName.Len() ) + { + List& rMgrList = GetResMgrList(); + + InternalResMgr* pEle = (InternalResMgr*)rMgrList.First(); + while( pEle ) + { + if ( rFileName.EqualsIgnoreCaseAscii( pEle->aFileName ) || + rFileName.EqualsIgnoreCaseAscii( pEle->aShortFileName ) ) + { + pEle->AddRef(); + return pEle; + } + pEle = (InternalResMgr*)rMgrList.Next(); + } + +#ifdef DBG_UTIL + ByteString aTraceStr( "Search/Load-RESDLL:" ); + aTraceStr += ByteString( rFileName, RTL_TEXTENCODING_UTF8 ); + DBG_TRACE( aTraceStr.GetBuffer() ); +#endif + + pEle = Create( rFileName, pAppName, pResPath ); + + if ( pEle ) + { + pEle->AddRef(); + rMgrList.Insert( pEle ); + } + + return pEle; + } + + return NULL; +} + +// ----------------------------------------------------------------------- + +void InternalResMgr::FreeInternalResMgr( InternalResMgr* pFreeInternalResMgr ) +{ + // Nur InternalResMgr's mit FileNamen stehen in der Liste und werden vor dem + // Programmende freigegeben + if( pFreeInternalResMgr->aFileName.Len() ) + { + if( pFreeInternalResMgr->ReleaseRef() == 0 ) + GetResMgrList().Remove( pFreeInternalResMgr ); + } +} + +// ----------------------------------------------------------------------- + +BOOL InternalResMgr::IsGlobalAvailable( RESOURCE_TYPE nRT, USHORT nId ) const +{ + // Anfang der Strings suchen + ImpContent * pFind = (ImpContent *) + bsearch( (void *)((ULONG(nRT) << 16) | nId), pContent, nEntries, + sizeof( ImpContent ), Search ); + return pFind != NULL; +} + +// ----------------------------------------------------------------------- + +void* InternalResMgr::LoadGlobalRes( RESOURCE_TYPE nRT, USHORT nId, + void **pResHandle ) +{ +#ifdef DBG_UTIL + if( pResUseDump ) + pResUseDump->Remove( (ULONG(nRT) << 16) | nId ); +#endif + // Anfang der Strings suchen + ImpContent * pFind = (ImpContent *) + bsearch( (void *)((ULONG(nRT) << 16) | nId), pContent, nEntries, + sizeof( ImpContent ), Search ); + if( nRT == RSC_STRING && bEqual2Content && pFind ) + { + // String Optimierung + if( !pStringBlock ) + { + // Anfang der Strings suchen + ImpContent * pFirst = pFind; + ImpContent * pLast = pFirst; + while( pFirst > pContent && ((pFirst -1)->nTypeAndId >> 16) == RSC_STRING ) + pFirst--; + while( pLast < (pContent + nEntries) && (pLast->nTypeAndId >> 16) == RSC_STRING ) + pLast++; + nOffCorrection = pFirst->nOffset; + UINT32 nSize; + --pLast; + pStm->Seek( pLast->nOffset ); + RSHEADER_TYPE aHdr; + pStm->Read( &aHdr, sizeof( aHdr ) ); + nSize = pLast->nOffset + aHdr.GetGlobOff() - nOffCorrection; + pStringBlock = (BYTE*)SvMemAlloc( nSize ); + pStm->Seek( pFirst->nOffset ); + pStm->Read( pStringBlock, nSize ); + } + *pResHandle = pStringBlock; + return (BYTE*)pStringBlock + pFind->nOffset - nOffCorrection; + } + *pResHandle = 0; + if( pFind ) + { + RSHEADER_TYPE aHeader; + pStm->Seek( pFind->nOffset ); + pStm->Read( &aHeader, sizeof( RSHEADER_TYPE ) ); + void * pRes = new BYTE[ aHeader.GetGlobOff() ]; + memcpy( pRes, &aHeader, sizeof( RSHEADER_TYPE ) ); + pStm->Read( (BYTE*)pRes + sizeof( RSHEADER_TYPE ), + aHeader.GetGlobOff() - sizeof( RSHEADER_TYPE ) ); + return pRes; + } + //Resource holen + return NULL; +} + +// ----------------------------------------------------------------------- + +void InternalResMgr::FreeGlobalRes( void * pResHandle, void * pResource ) +{ + if ( !pResHandle ) + // REsource wurde extra allokiert + delete pResource; +} + +// ======================================================================= + +#ifdef DBG_UTIL + +UniString GetTypeRes_Impl( const ResId& rTypeId ) +{ + // Funktion verlassen, falls Resourcefehler in dieser Funktion + static bInUse = FALSE; + UniString aTypStr( rTypeId.GetId() ); + + if ( !bInUse ) + { + bInUse = TRUE; + + ResId aResId( RSCVERSION_ID ); + aResId.SetRT( RSC_VERSIONCONTROL ); + + if ( rTypeId.GetResMgr()->GetResource( aResId ) ) + { + rTypeId.SetRT( RSC_STRING ); + if ( rTypeId.GetResMgr()->IsAvailable( rTypeId ) ) + { + aTypStr = UniString( rTypeId ); + // Versions Resource Klassenzeiger ans Ende setzen + Resource::GetResManager()->Increment( sizeof( RSHEADER_TYPE ) ); + } + } + bInUse = FALSE; + } + + return aTypStr; +} + +// ----------------------------------------------------------------------- + +static void RscError_Impl( const sal_Char* pMessage, ResMgr* pResMgr, + RESOURCE_TYPE nRT, USHORT nId, + ImpRCStack* pResStack, short nStackTop ) +{ + // neuen ResourceMgr erzeugen + ResMgr* pNewResMgr = new ResMgr( pResMgr->GetFileName() ); + + ByteString aStr = ByteString( pResMgr->GetFileName(), RTL_TEXTENCODING_UTF8 ); + if ( aStr.Len() ) + aStr += '\n'; + + aStr.Append( "Class: " ); + aStr.Append( ByteString( GetTypeRes_Impl( ResId( nRT, pNewResMgr ) ), RTL_TEXTENCODING_UTF8 ) ); + aStr.Append( ", Id: " ); + aStr.Append( ByteString::CreateFromInt32( (long)nId ) ); + aStr.Append( ". " ); + aStr.Append( pMessage ); + + aStr.Append( "\nResource Stack\n" ); + while( nStackTop > 0 ) + { + aStr.Append( "Class: " ); + aStr.Append( ByteString( GetTypeRes_Impl( ResId( (pResStack + nStackTop)->pResource->GetRT(), pNewResMgr ) ), RTL_TEXTENCODING_UTF8 ) ); + aStr.Append( ", Id: " ); + aStr.Append( ByteString::CreateFromInt32( (long)(pResStack + nStackTop)->pResource->GetId() ) ); + nStackTop--; + } + + delete pNewResMgr; + + DBG_ERROR( aStr.GetBuffer() ); +} + +#endif + +// ======================================================================= + +static void RscException_Impl() +{ + switch ( NAMESPACE_VOS(OSignalHandler)::raise( OSL_SIGNAL_USER_RESOURCEFAILURE, (void*)"" ) ) + { + case NAMESPACE_VOS(OSignalHandler)::TAction_CallNextHandler: + abort(); + break; + + case NAMESPACE_VOS(OSignalHandler)::TAction_Ignore: + return; + break; + + case NAMESPACE_VOS(OSignalHandler)::TAction_AbortApplication: + abort(); + break; + + case NAMESPACE_VOS(OSignalHandler)::TAction_KillApplication: + exit(-1); + break; + } +} + +// ======================================================================= + +void ImpRCStack::Init( ResMgr* pMgr, const Resource* pObj, USHORT Id ) +{ + pResource = NULL; + pClassRes = NULL; + Flags = RC_NOTYPE; + aResHandle = NULL; + pResObj = pObj; + nId = Id & ~RSC_DONTRELEASE; //TLX: Besser Init aendern + pResMgr = pMgr; + if ( !(Id & RSC_DONTRELEASE) ) + Flags |= RC_AUTORELEASE; +} + +// ----------------------------------------------------------------------- + +void ImpRCStack::Clear() +{ + pResource = NULL; + pClassRes = NULL; + Flags = RC_NOTYPE; + aResHandle = NULL; + pResObj = NULL; + nId = 0; + pResMgr = NULL; +} + +// ----------------------------------------------------------------------- + +static RSHEADER_TYPE* LocalResource( const ImpRCStack* pStack, + RESOURCE_TYPE nRTType, + USHORT nId ) +{ + // Gibt die Position der Resource zurueck, wenn sie gefunden wurde. + // Ansonsten gibt die Funktion Null zurueck. + RSHEADER_TYPE* pTmp; // Zeiger auf Kind-Resourceobjekte + RSHEADER_TYPE* pEnd; // Zeiger auf das Ende der Resource + + if ( pStack->pResource && pStack->pClassRes ) + { + pTmp = (RSHEADER_TYPE*) + ((BYTE*)pStack->pResource + pStack->pResource->GetLocalOff()); + pEnd = (RSHEADER_TYPE*) + ((BYTE*)pStack->pResource + pStack->pResource->GetGlobOff()); + while ( pTmp != pEnd ) + { + if ( pTmp->GetRT() == nRTType && pTmp->GetId() == nId ) + return pTmp; + pTmp = (RSHEADER_TYPE*)((BYTE*)pTmp + pTmp->GetGlobOff()); + } + } + + return NULL; +} + +// ======================================================================= + +void ResMgr::DestroyAllResMgr() +{ + ImplSVResourceData* pSVInData = GetResData(); + + // Da auch von Abort gerufen werden kann, geben wir alle + // ResMgr's und alle InternalResMgr's hier frei + List* pMgrList = pSVInData->pInternalResMgrList; + if ( pMgrList ) + { + InternalResMgr* pEle = (InternalResMgr*)pMgrList->First(); + while ( pEle ) + { + DBG_WARNING1( "ResMgr's not destroyed: %s", + ByteString( pEle->aFileName, RTL_TEXTENCODING_UTF8 ).GetBuffer() ); + pEle->ReleaseReference(); + pEle = (InternalResMgr*)pMgrList->Next(); + } + delete pMgrList; + } +} + +// ----------------------------------------------------------------------- + +void ResMgr::Init( const UniString& rFileName ) +{ + if ( !pImpRes ) + { +#ifdef DBG_UTIL + ByteString aStr( "Resourcefile not found:\n" ); + aStr += ByteString( rFileName, RTL_TEXTENCODING_UTF8 ); + DBG_ERROR( aStr.GetBuffer() ); +#endif + RscException_Impl(); + } +#ifdef DBG_UTIL + else + { + void* aResHandle = 0; // Hilfvariable fuer Resource + void* pVoid; // Zeiger auf die Resource + + pVoid = pImpRes->LoadGlobalRes( RSC_VERSIONCONTROL, RSCVERSION_ID, + &aResHandle ); + if ( pVoid ) + pImpRes->FreeGlobalRes( aResHandle, pVoid ); + else + { + ByteString aStr( "Wrong version:\n" ); + aStr += ByteString( pImpRes->aFileName, RTL_TEXTENCODING_UTF8 ); + DbgError( aStr.GetBuffer() ); + } + } +#endif + + nTopRes = 0; + aStack[0].Clear(); +} + +// ----------------------------------------------------------------------- + +ResMgr::ResMgr( const UniString& rFileName, + const UniString* pAppName, + const UniString* pResPath ) +{ + pImpRes = InternalResMgr::GetInternalResMgr( rFileName, pAppName, pResPath ); + Init( pImpRes ? (const UniString&)pImpRes->aFileName : rFileName ); +} + +// ----------------------------------------------------------------------- + +ResMgr::ResMgr( InternalResMgr * pImpMgr ) +{ + pImpRes = pImpMgr; + Init( pImpMgr->aFileName ); +} + +// ----------------------------------------------------------------------- + +ResMgr::~ResMgr() +{ + InternalResMgr::FreeInternalResMgr( pImpRes ); +} + +// ----------------------------------------------------------------------- + +#ifdef DBG_UTIL + +void ResMgr::TestStack( const Resource* pResObj ) +{ + if ( DbgIsResource() ) + { + for( short i = 1; i <= nTopRes; i++ ) + { + if ( aStack[i].pResObj == pResObj ) + { +#ifdef DBG_UTIL + RscError_Impl( "Resource not freed! ", this, + aStack[i].pResource->GetRT(), + aStack[i].pResource->GetId(), + aStack, i -1 ); +#endif + } + } + } +} + +#else + +void ResMgr::TestStack( const Resource* ) +{ +} + +#endif + +// ----------------------------------------------------------------------- + +BOOL ResMgr::IsAvailable( const ResId& rId, const Resource* pResObj ) const +{ + BOOL bAvailable = FALSE; + RSHEADER_TYPE* pClassRes = rId.GetpResource(); + RESOURCE_TYPE nRT = rId.GetRT2(); + USHORT nId = rId.GetId(); + const ResMgr* pMgr = rId.GetResMgr(); + + if ( !pMgr ) + pMgr = this; + + if ( !pResObj || pResObj == pMgr->aStack[pMgr->nTopRes].pResObj ) + { + if ( !pClassRes ) + pClassRes = LocalResource( &pMgr->aStack[pMgr->nTopRes], nRT, nId ); + if ( pClassRes ) + { + if ( pClassRes->GetRT() == nRT ) + bAvailable = TRUE; + } + } + + // vieleicht globale Resource + if ( !pClassRes ) + bAvailable = pMgr->pImpRes->IsGlobalAvailable( nRT, nId ); + + return bAvailable; +} + +// ----------------------------------------------------------------------- + +inline ResMgr* GetActualResMgr() +{ + return GetResData()->pAppResMgr; +} + +// ----------------------------------------------------------------------- + +BOOL ResMgr::GetResource( const ResId& rId, const Resource* pResObj ) +{ + DBG_TESTSOLARMUTEX(); + + ResMgr* pMgr = rId.GetResMgr(); + if ( pMgr && (this != pMgr) ) + return pMgr->GetResource( rId, pResObj ); + + RSHEADER_TYPE* pClassRes = rId.GetpResource(); + RESOURCE_TYPE nRT = rId.GetRT2(); + USHORT nId = rId.GetId(); + + ResMgr* pLastMgr = GetActualResMgr(); + if ( pLastMgr != this ) + Resource::SetResManager( this ); + + nTopRes++; // Stackzeiger erhoehen + ImpRCStack* pTop = &aStack[nTopRes]; + pTop->Init( pLastMgr, pResObj, nId | + (rId.IsAutoRelease() ? 0 : RSC_DONTRELEASE) ); + + if ( pClassRes ) + { + if ( pClassRes->GetRT() == nRT ) + pTop->pClassRes = pClassRes; + else + { +#ifdef DBG_UTIL + RscError_Impl( "Different class and resource type!", + this, nRT, nId, aStack, nTopRes -1 ); +#endif + RscException_Impl(); + nTopRes--; + return FALSE; + } + } + else + pTop->pClassRes = LocalResource( pTop -1, nRT, nId ); + + if ( pTop->pClassRes ) + // lokale Resource, nicht system Resource + pTop->pResource = (RSHEADER_TYPE *)pTop->pClassRes; + else + { + pTop->Flags |= RC_GLOBAL; + pTop->pClassRes = pImpRes->LoadGlobalRes( nRT, nId, &pTop->aResHandle ); + if ( pTop->pClassRes ) + pTop->pResource = (RSHEADER_TYPE *)pTop->pClassRes; + else + { +#ifdef DBG_UTIL + RscError_Impl( "Cannot load resource! ", + this, nRT, nId, aStack, nTopRes -1 ); +#endif + RscException_Impl(); + ImplSVResourceData * pRD = GetResData(); + nTopRes--; + return FALSE; + } + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +void * ResMgr::GetResourceSkipHeader( const ResId& rResId, ResMgr ** ppResMgr ) +{ + if ( rResId.GetResMgr() ) + *ppResMgr = rResId.GetResMgr(); + else + *ppResMgr = Resource::GetResManager(); + (*ppResMgr)->GetResource( rResId ); + (*ppResMgr)->Increment( sizeof( RSHEADER_TYPE ) ); + return (*ppResMgr)->GetClass(); +} + +// ----------------------------------------------------------------------- + +#ifdef DBG_UTIL +void ResMgr::PopContext( const Resource* pResObj ) +#else +void ResMgr::PopContext( const Resource* ) +#endif +{ +#ifdef DBG_UTIL + if ( DbgIsResource() ) + { + if ( (aStack[nTopRes].pResObj != pResObj) || !nTopRes ) + { + RscError_Impl( "Cannot free resource! ", this, + RSC_NOTYPE, 0, aStack, nTopRes ); + } + } +#endif + + if ( nTopRes ) + { + ImpRCStack* pTop = &aStack[nTopRes]; +#ifdef DBG_UTIL + if ( DbgIsResource() ) + { + void* pRes = (BYTE*)pTop->pResource + + pTop->pResource->GetLocalOff(); + + if ( pTop->pClassRes != pRes ) + { + RscError_Impl( "Classpointer not at the end!", + this, pTop->pResource->GetRT(), + pTop->pResource->GetId(), + aStack, nTopRes -1 ); + } + } +#endif + + // Resource freigeben + if ( pTop->Flags & RC_GLOBAL ) + // kann auch Fremd-Ressource sein + pImpRes->FreeGlobalRes( pTop->aResHandle, pTop->pResource ); + if ( pTop->pResMgr != this ) + // wurde durch ResId gesetzt, automatisch zuruecksetzen + Resource::SetResManager( pTop->pResMgr ); + nTopRes--; + } +} + +// ----------------------------------------------------------------------- + +RSHEADER_TYPE* ResMgr::CreateBlock( const ResId& rId ) +{ + RSHEADER_TYPE* pHeader = NULL; + if ( GetResource( rId ) ) + { + // Der Zeiger steht am Anfang, deswegen zeigt der Klassen-Pointer + // auf den Header und die restliche Groesse ist die Gesammte. + pHeader = (RSHEADER_TYPE*)new BYTE[ GetRemainSize() ]; + memcpy( pHeader, GetClass(), GetRemainSize() ); + Increment( pHeader->GetLocalOff() ); //ans Ende setzen + if ( pHeader->GetLocalOff() != pHeader->GetGlobOff() ) + // Hat Sub-Ressourcen, deshalb extra freigeben + PopContext(); + } + + return pHeader; +} + +// ------------------------------------------------------------------ + +INT16 ResMgr::GetShort( void * pShort ) +{ +#ifdef __BIGENDIAN + return *(UINT16*)pShort; +#else + return SWAPSHORT( *(UINT16*)pShort ); +#endif +} + +// ------------------------------------------------------------------ + +INT32 ResMgr::GetLong( void * pLong ) +{ +#ifdef __BIGENDIAN + return (long)(((INT32)(*(UINT16*)pLong) << 16) | *(((UINT16*)pLong) + 1)); +#else + return ((INT32)(*(BYTE*)pLong) << 24) + | ((INT32)(*((BYTE*)pLong +1)) << 16) + | ((INT32)(*((BYTE*)pLong +2)) << 8) + | (INT32)(*((BYTE*)pLong +3)); +#endif +} + +// ----------------------------------------------------------------------- + +USHORT ResMgr::GetString( UniString& rStr, const BYTE* pStr ) +{ + UniString aString( (sal_Char*)pStr, RTL_TEXTENCODING_UTF8, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT ); + rStr = aString; + return GetStringSize( pStr ); +} + +// ------------------------------------------------------------------ + +USHORT ResMgr::GetStringSize( const BYTE* pStr ) +{ + return GetStringSize( strlen( (const char*)pStr ) ); +} + +// ----------------------------------------------------------------------- + +USHORT ResMgr::GetRemainSize() +{ + return (USHORT)((long)(BYTE *)aStack[nTopRes].pResource + + aStack[nTopRes].pResource->GetLocalOff() - + (long)(BYTE *)aStack[nTopRes].pClassRes); +} + +// ----------------------------------------------------------------------- + +void* ResMgr::Increment( USHORT nSize ) +{ + BYTE* pClassRes = (BYTE*)aStack[nTopRes].pClassRes + nSize; + + aStack[nTopRes].pClassRes = pClassRes; + + RSHEADER_TYPE* pRes = aStack[nTopRes].pResource; + + if ( (pRes->GetGlobOff() == pRes->GetLocalOff()) && + (((char*)pRes + pRes->GetLocalOff()) == aStack[nTopRes].pClassRes) && + (aStack[nTopRes].Flags & RC_AUTORELEASE)) + { + PopContext( aStack[nTopRes].pResObj ); + } + + return pClassRes; +} + +// ----------------------------------------------------------------------- + +const char* ResMgr::GetLang( LanguageType& nType, USHORT nPrio ) +{ + static sal_Char const aDefEng[] = "44"; + static sal_Char const aDefUSEng[] = "01"; + static sal_Char const aDefGerman[] = "49"; + static sal_Char const aDefFrench[] = "33"; + static sal_Char const aDefPortuguese[] = "03"; + + if ( nType == LANGUAGE_SYSTEM || nType == LANGUAGE_DONTKNOW ) + nType = ::GetSystemLanguage(); + + if ( nPrio == 0 ) + { + switch ( nType ) + { + case LANGUAGE_DANISH: + return "45"; + + case LANGUAGE_DUTCH: + case LANGUAGE_DUTCH_BELGIAN: + return "31"; + + case LANGUAGE_ENGLISH: + case LANGUAGE_ENGLISH_UK: + case LANGUAGE_ENGLISH_EIRE: + case LANGUAGE_ENGLISH_SAFRICA: + case LANGUAGE_ENGLISH_JAMAICA: + case LANGUAGE_ENGLISH_BELIZE: + case LANGUAGE_ENGLISH_TRINIDAD: + case LANGUAGE_ENGLISH_ZIMBABWE: + case LANGUAGE_ENGLISH_PHILIPPINES: + return aDefEng; + + case LANGUAGE_ENGLISH_US: + case LANGUAGE_ENGLISH_CAN: + return aDefUSEng; + + case LANGUAGE_ENGLISH_AUS: + case LANGUAGE_ENGLISH_NZ: + return "61"; + + case LANGUAGE_FINNISH: + return "05"; + + case LANGUAGE_FRENCH_CANADIAN: + return "02"; + + case LANGUAGE_FRENCH: + case LANGUAGE_FRENCH_BELGIAN: + case LANGUAGE_FRENCH_SWISS: + case LANGUAGE_FRENCH_LUXEMBOURG: + case LANGUAGE_FRENCH_MONACO: + return aDefFrench; + + case LANGUAGE_GERMAN: + case LANGUAGE_GERMAN_SWISS: + case LANGUAGE_GERMAN_AUSTRIAN: + case LANGUAGE_GERMAN_LUXEMBOURG: + case LANGUAGE_GERMAN_LIECHTENSTEIN: + return aDefGerman; + + case LANGUAGE_ITALIAN: + case LANGUAGE_ITALIAN_SWISS: + return "39"; + + case LANGUAGE_NORWEGIAN: + case LANGUAGE_NORWEGIAN_BOKMAL: + return "47"; + + case LANGUAGE_PORTUGUESE: + return aDefPortuguese; + + case LANGUAGE_PORTUGUESE_BRAZILIAN: + return "55"; + + case LANGUAGE_SPANISH: + case LANGUAGE_SPANISH_MEXICAN: + case LANGUAGE_SPANISH_MODERN: + case LANGUAGE_SPANISH_GUATEMALA: + case LANGUAGE_SPANISH_COSTARICA: + case LANGUAGE_SPANISH_PANAMA: + case LANGUAGE_SPANISH_DOMINICAN_REPUBLIC: + case LANGUAGE_SPANISH_VENEZUELA: + case LANGUAGE_SPANISH_COLOMBIA: + case LANGUAGE_SPANISH_PERU: + case LANGUAGE_SPANISH_ARGENTINA: + case LANGUAGE_SPANISH_ECUADOR: + case LANGUAGE_SPANISH_CHILE: + case LANGUAGE_SPANISH_URUGUAY: + case LANGUAGE_SPANISH_PARAGUAY: + case LANGUAGE_SPANISH_BOLIVIA: + return "34"; + + case LANGUAGE_SWEDISH: + return "46"; + + case LANGUAGE_POLISH: + return "48"; + case LANGUAGE_CZECH: + return "42"; + case LANGUAGE_HUNGARIAN: + return "36"; + case LANGUAGE_RUSSIAN: + return "07"; + case LANGUAGE_SLOVAK: + return "04"; + case LANGUAGE_GREEK: + return "30"; + case LANGUAGE_TURKISH: + return "90"; + + case LANGUAGE_CHINESE_SIMPLIFIED: + return "86"; + case LANGUAGE_CHINESE_TRADITIONAL: + return "88"; + case LANGUAGE_JAPANESE: + return "81"; + case LANGUAGE_KOREAN: + case LANGUAGE_KOREAN_JOHAB: + return "82"; + + case LANGUAGE_ARABIC: + case LANGUAGE_ARABIC_IRAQ: + case LANGUAGE_ARABIC_EGYPT: + case LANGUAGE_ARABIC_LIBYA: + case LANGUAGE_ARABIC_ALGERIA: + case LANGUAGE_ARABIC_MOROCCO: + case LANGUAGE_ARABIC_TUNISIA: + case LANGUAGE_ARABIC_OMAN: + case LANGUAGE_ARABIC_YEMEN: + case LANGUAGE_ARABIC_SYRIA: + case LANGUAGE_ARABIC_JORDAN: + case LANGUAGE_ARABIC_LEBANON: + case LANGUAGE_ARABIC_KUWAIT: + case LANGUAGE_ARABIC_UAE: + case LANGUAGE_ARABIC_BAHRAIN: + case LANGUAGE_ARABIC_QATAR: + return "96"; + + default: + return aDefUSEng; + } + } + else if ( nPrio == 1 ) + { + switch ( nType ) + { + case LANGUAGE_FRENCH_CANADIAN: + return aDefFrench; + + case LANGUAGE_PORTUGUESE_BRAZILIAN: + return aDefPortuguese; + + default: + return NULL; + } + } + else if ( nPrio == 2 ) + return aDefUSEng; + else if ( nPrio == 3 ) + return aDefEng; + else + return aDefGerman; +} + +// ----------------------------------------------------------------------- + +ResMgr* ResMgr::CreateResMgr( const sal_Char* pPrefixName, + LanguageType nType, + const UniString* pAppName, + const UniString* pResPath ) +{ + // Suchreihenfolge festlegen + const sal_Char* pLang[5]; + + // Resourcefile suchen + UniString aName; + InternalResMgr* pInternalResMgr = NULL; + for ( int i = 0; i < 5; i++ ) + { + pLang[i] = GetLang( nType, i ); + + if ( pLang[i] && (i == 0 || pLang[i] != pLang[0]) ) + { + aName.AssignAscii( pPrefixName ); + aName.AppendAscii( pLang[i] ); + aName.AppendAscii( ".res" ); + pInternalResMgr = InternalResMgr::GetInternalResMgr( aName, pAppName, pResPath ); + if ( pInternalResMgr ) + break; + } + } + + if ( pInternalResMgr ) + return new ResMgr( pInternalResMgr ); + + return NULL; +} + +// ----------------------------------------------------------------------- + +INT16 ResMgr::ReadShort() +{ + INT16 n = GetShort( GetClass() ); + Increment( sizeof( INT16 ) ); + return n; +} + +// ----------------------------------------------------------------------- + +INT32 ResMgr::ReadLong() +{ + INT32 n = GetLong( GetClass() ); + Increment( sizeof( INT32 ) ); + return n; +} + +// ----------------------------------------------------------------------- + +UniString ResMgr::ReadString() +{ + UniString aRet; + Increment( GetString( aRet, (const BYTE*)GetClass() ) ); + return aRet; +} + +// ======================================================================= + +SimpleResMgr::SimpleResMgr( const sal_Char* pPrefixName, + LanguageType nType, + const UniString* pAppName, + const UniString* pResPath ) +{ + // Suchreihenfolge festlegen + const sal_Char* pLang[5]; + + // Resourcefile suchen + UniString aName; + for ( int i = 0; i < 5; i++ ) + { + pLang[i] = ResMgr::GetLang( nType, i ); + + if ( pLang[i] && (i == 0 || pLang[i] != pLang[0]) ) + { + aName.AssignAscii( pPrefixName ); + aName.AppendAscii( pLang[i] ); + aName.AppendAscii( ".res" ); + m_pResImpl = InternalResMgr::Create( aName, pAppName, pResPath ); + if ( m_pResImpl ) + break; + } + } +} + +// ----------------------------------------------------------------------- + +SimpleResMgr::~SimpleResMgr() +{ + delete m_pResImpl; +} + +// ----------------------------------------------------------------------- + +UniString SimpleResMgr::ReadString( USHORT nId ) +{ + NAMESPACE_VOS(OGuard) aGuard(m_aAccessSafety); + + DBG_ASSERT( m_pResImpl, "SimpleResMgr::ReadString : have no impl class !" ); + // perhaps constructed with an invalid filename ? + + UniString sReturn; + if ( !m_pResImpl ) + return sReturn; + + void* pResHandle = NULL; + RSHEADER_TYPE* pResHeader = (RSHEADER_TYPE*)m_pResImpl->LoadGlobalRes( RSC_STRING, nId, &pResHandle ); + if ( !pResHeader ) + // no such resource + return sReturn; + + USHORT nLen = pResHeader->GetLocalOff() - sizeof(RSHEADER_TYPE); + ResMgr::GetString( sReturn, (const BYTE*)(pResHeader+1) ); + + // not neccessary with te current implementation which holds the string table permanently, but to be sure .... + m_pResImpl->FreeGlobalRes( pResHeader, pResHandle ); + return sReturn; +} + +// ----------------------------------------------------------------------- + +USHORT SimpleResMgr::ReadBlob( USHORT nId, void** pBuffer ) +{ + NAMESPACE_VOS(OGuard) aGuard(m_aAccessSafety); + + DBG_ASSERT( m_pResImpl, "SimpleResMgr::ReadBlob : have no impl class !" ); + + // perhaps constructed with an invalid filename ? + DBG_ASSERT( pBuffer, "SimpleResMgr::ReadBlob : invalid argument !" ); + *pBuffer = NULL; + + void* pResHandle = NULL; + RSHEADER_TYPE* pResHeader = (RSHEADER_TYPE*)m_pResImpl->LoadGlobalRes( RSC_RESOURCE, nId, &pResHandle ); + DBG_ASSERT( pResHeader, "SimpleResMgr::ReadBlob : couldn't find the resource with the given id !" ); + + // no exception handling, this would require the locking of the solar mutex which isn't allowed within this class + if ( !pResHeader ) + return 0; + + DBG_ASSERT( pResHandle == NULL, "SimpleResMgr::ReadBlob : behaviour of LoadGlobalRes changed !" ); + // if pResHandle is not NULL the FreeBlob wouldn't have to delete the pointer given as pBuffer, but + // FreeBlob doesn't know that so it would probably crash .... + + USHORT nRemaining = pResHeader->GetLocalOff() - sizeof(RSHEADER_TYPE); + *pBuffer = (void*)(((BYTE*)pResHeader) + sizeof(RSHEADER_TYPE)); + return nRemaining; +} + +// ----------------------------------------------------------------------- + +void SimpleResMgr::FreeBlob( void* pBuffer ) +{ + void* pCompleteBuffer = (void*)(((BYTE*)pBuffer) - sizeof(RSHEADER_TYPE)); + delete pCompleteBuffer; +} diff --git a/tools/source/ref/errinf.cxx b/tools/source/ref/errinf.cxx new file mode 100644 index 000000000000..3db59910725c --- /dev/null +++ b/tools/source/ref/errinf.cxx @@ -0,0 +1,443 @@ +/************************************************************************* + * + * $RCSfile: errinf.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <limits.h> +#include <shl.hxx> +#include <debug.hxx> +#include <errinf.hxx> +#include <string.hxx> + +class ErrorHandler; + +struct EDcrData +{ + public: + + ErrorHandler *pFirstHdl; + ErrorContext *pFirstCtx; + void *pDsp; + BOOL bIsWindowDsp; + + + DynamicErrorInfo *ppDcr[ERRCODE_DYNAMIC_COUNT]; + USHORT nNextDcr; + EDcrData(); + +static EDcrData *GetData(); + +}; + +class EDcr_Impl +{ + ULONG lErrId; + USHORT nMask; + + void RegisterEDcr(DynamicErrorInfo *); + void UnRegisterEDcr(DynamicErrorInfo *); + static ErrorInfo *GetDynamicErrorInfo(ULONG lId); + +friend class DynamicErrorInfo; +friend class ErrorInfo; +}; + + +EDcrData::EDcrData() +{ + for(USHORT n=0;n<ERRCODE_DYNAMIC_COUNT;n++) + ppDcr[n]=0; + nNextDcr=0; + pFirstHdl=0; + pDsp=0; + pFirstCtx=0; +} + + +EDcrData *EDcrData::GetData() +{ +#ifdef BOOTSTRAP + return 0x0; +#else + EDcrData **ppDat=(EDcrData **)GetAppData(SHL_ERR); + if(!*ppDat) + { + return (*ppDat=new EDcrData); + } + else + return *ppDat; +#endif +} + +void EDcr_Impl::RegisterEDcr(DynamicErrorInfo *pDcr) +{ + //Vergibt eine dynamische Id + + EDcrData* pData=EDcrData::GetData(); + lErrId= (((ULONG)pData->nNextDcr + 1) << ERRCODE_DYNAMIC_SHIFT) + + pDcr->GetErrorCode(); + DynamicErrorInfo **ppDcr=pData->ppDcr; + USHORT nNext=pData->nNextDcr; + + // bei einem Ringbuffer koennen wir uns das ASSERT wohl sparen! + // DBG_ASSERT(ppDcr[nNext]==0,"ErrHdl: Alle Errors belegt"); + if(ppDcr[nNext]) + { + delete ppDcr[nNext]; + } + ppDcr[nNext]=pDcr; + if(++pData->nNextDcr>=ERRCODE_DYNAMIC_COUNT) + pData->nNextDcr=0; +} + + +void EDcr_Impl::UnRegisterEDcr(DynamicErrorInfo *pDcr) +{ + + EDcrData* pData=EDcrData::GetData(); + DynamicErrorInfo **ppDcr=pData->ppDcr; + ULONG lIdx=( + ((ULONG)(*pDcr) & ERRCODE_DYNAMIC_MASK)>>ERRCODE_DYNAMIC_SHIFT)-1; + DBG_ASSERT(ppDcr[lIdx]==pDcr,"ErrHdl: Error nicht gefunden"); + if(ppDcr[lIdx]==pDcr) + ppDcr[lIdx]=0; +} + +TYPEINIT0(ErrorInfo); +TYPEINIT1(DynamicErrorInfo, ErrorInfo); +TYPEINIT1(StandardErrorInfo, DynamicErrorInfo); +TYPEINIT1(StringErrorInfo, DynamicErrorInfo); +TYPEINIT1(TwoStringErrorInfo, DynamicErrorInfo); +TYPEINIT1(MessageInfo, DynamicErrorInfo); + + +ErrorInfo *ErrorInfo::GetErrorInfo(ULONG lId) +{ + if(lId & ERRCODE_DYNAMIC_MASK) + return EDcr_Impl::GetDynamicErrorInfo(lId); + else + return new ErrorInfo(lId); +} + +DynamicErrorInfo::operator ULONG() const +{ + return pImpl->lErrId; +} + +DynamicErrorInfo::DynamicErrorInfo(ULONG lArgUserId, USHORT nMask) +: ErrorInfo(lArgUserId) +{ + pImpl=new EDcr_Impl; + pImpl->RegisterEDcr(this); + pImpl->nMask=nMask; +} + +DynamicErrorInfo::~DynamicErrorInfo() +{ + pImpl->UnRegisterEDcr(this); + delete pImpl; +} + +ErrorInfo* EDcr_Impl::GetDynamicErrorInfo(ULONG lId) +{ + ULONG lIdx=((lId & ERRCODE_DYNAMIC_MASK)>>ERRCODE_DYNAMIC_SHIFT)-1; + DynamicErrorInfo* pDcr=EDcrData::GetData()->ppDcr[lIdx]; + if(pDcr && (ULONG)(*pDcr)==lId) + return pDcr; + else + return new ErrorInfo(lId & ~ERRCODE_DYNAMIC_MASK); +} + + +USHORT DynamicErrorInfo::GetDialogMask() const +{ + return pImpl->nMask; +} + + +StandardErrorInfo::StandardErrorInfo( + ULONG lUserId, ULONG lArgExtId, USHORT nFlags) +: DynamicErrorInfo(lUserId, nFlags), lExtId(lArgExtId) +{ +} + + +StringErrorInfo::StringErrorInfo( + ULONG lUserId, const String& aStringP, USHORT nFlags) +: DynamicErrorInfo(lUserId, nFlags), aString(aStringP) +{ +} + + +class ErrHdl_Impl +{ + public: + + ErrorHandler *pNext; + static BOOL CreateString(const ErrorHandler *pStart, + const ErrorInfo*, String&, USHORT&); +}; + + +static void aDspFunc(const String &rErr, const String &rAction) +{ + ByteString aErr("Aktion: "); + aErr+= ByteString( rAction, RTL_TEXTENCODING_ASCII_US ); + aErr+=" Fehler: "; + aErr+= ByteString( rErr, RTL_TEXTENCODING_ASCII_US ); + DBG_ERROR(aErr.GetBuffer()); +} + + +ErrorContext::ErrorContext(Window *pWinP) +{ + EDcrData *pData=EDcrData::GetData(); + ErrorContext *&pHdl=pData->pFirstCtx; + pWin=pWinP; + pNext=pHdl; + pHdl=this; +} + +ErrorContext::~ErrorContext() +{ + ErrorContext **ppCtx=&(EDcrData::GetData()->pFirstCtx); + while(*ppCtx && *ppCtx!=this) + ppCtx=&((*ppCtx)->pNext); + if(*ppCtx) + *ppCtx=(*ppCtx)->pNext; +} + +ErrorContext *ErrorContext::GetContext() +{ + return EDcrData::GetData()->pFirstCtx; +} + +ErrorHandler::ErrorHandler() +{ + pImpl=new ErrHdl_Impl; + EDcrData *pData=EDcrData::GetData(); + ErrorHandler *&pHdl=pData->pFirstHdl; + pImpl->pNext=pHdl; + pHdl=this; + if(!pData->pDsp) + RegisterDisplay(&aDspFunc); +} + +ErrorHandler::~ErrorHandler() +{ + ErrorHandler **ppHdl=&(EDcrData::GetData()->pFirstHdl); + while(*ppHdl && *ppHdl!=this) + ppHdl=&((*ppHdl)->pImpl->pNext); + if(*ppHdl) + *ppHdl=(*ppHdl)->pImpl->pNext; + delete pImpl; +} + +void ErrorHandler::RegisterDisplay(WindowDisplayErrorFunc *aDsp) +{ + EDcrData *pData=EDcrData::GetData(); + pData->bIsWindowDsp=TRUE; + pData->pDsp=(void*)aDsp; +} + +void ErrorHandler::RegisterDisplay(BasicDisplayErrorFunc *aDsp) +{ + EDcrData *pData=EDcrData::GetData(); + pData->bIsWindowDsp=FALSE; + pData->pDsp=(void*)aDsp; +} + +USHORT ErrorHandler::HandleError(ULONG lId, USHORT nFlags) +{ + +/* [Beschreibung] + Handelt einen Fehler ab. lId ist die FehlerId, nFlags sind die + ErrorFlags. Werden nFlags nicht abgegeben, so werden die in + der DynamicErrorInfo angegebenen Flags bzw. die aus der Resource + verwendet. + + Also: + + 1. nFlags, + 2. Resource Flags + 3. Dynamic Flags + 4. Default ERRCODE_BUTTON_OK, ERRCODE_MSG_ERROR + + + */ + + String aErr; + String aAction; + if(!lId || lId == ERRCODE_ABORT) + return 0; + EDcrData *pData=EDcrData::GetData(); + ErrorInfo *pInfo=ErrorInfo::GetErrorInfo(lId); + ErrorContext *pCtx=ErrorContext::GetContext(); + if(pCtx) + pCtx->GetString(pInfo->GetErrorCode(), aAction); + Window *pParent=0; + //Nimm den Parent aus dem Konext + for(;pCtx;pCtx=pCtx->pNext) + if(pCtx->GetParent()) + { + pParent=pCtx->GetParent(); + break; + } + + USHORT nErrFlags = ERRCODE_BUTTON_DEF_OK | ERRCODE_BUTTON_OK | + ERRCODE_MSG_ERROR; + + DynamicErrorInfo* pDynPtr=PTR_CAST(DynamicErrorInfo,pInfo); + if(pDynPtr) + { + USHORT nDynFlags = pDynPtr->GetDialogMask(); + if( nDynFlags ) + nErrFlags = nDynFlags; + } + + if(ErrHdl_Impl::CreateString(pData->pFirstHdl,pInfo,aErr,nErrFlags)) + { + delete pInfo; + if(!pData->pDsp) + { + + ByteString aStr("Action: "); + aStr += ByteString( aAction, RTL_TEXTENCODING_ASCII_US ); + aStr += ByteString("\nFehler: "); + aStr += ByteString( aErr, RTL_TEXTENCODING_ASCII_US ); + DBG_ERROR( aStr.GetBuffer() ); + } + else + if(!pData->bIsWindowDsp) + { + (*(BasicDisplayErrorFunc*)pData->pDsp)(aErr,aAction); + return 0; + } + else + { + if( nFlags != USHRT_MAX ) + nErrFlags = nFlags; + return (*(WindowDisplayErrorFunc*)pData->pDsp)( + pParent, nErrFlags, aErr, aAction); + } + } + + DBG_ERROR("Error nicht behandelt"); + // Error 1 ist General Error im Sfx + if(pInfo->GetErrorCode()!=1) + HandleError(1, USHRT_MAX); + else + DBG_ERROR("Error 1 nicht gehandeled"); + delete pInfo; + return 0; +} + +BOOL ErrorHandler::ForwCreateString(const ErrorInfo* pInfo, String& rStr, USHORT &rFlags) const +{ + return ErrHdl_Impl::CreateString(this->pImpl->pNext, pInfo, rStr, rFlags); +} + +BOOL ErrHdl_Impl::CreateString( const ErrorHandler *pStart, + const ErrorInfo* pInfo, String& pStr, + USHORT &rFlags) +{ + for(const ErrorHandler *pHdl=pStart;pHdl;pHdl=pHdl->pImpl->pNext) + { + if(pHdl->CreateString( pInfo, pStr, rFlags)) + return TRUE; + } + return FALSE; +} + +BOOL SimpleErrorHandler::CreateString( + const ErrorInfo *pInfo, String &rStr, USHORT &) const +{ + ULONG nId = pInfo->GetErrorCode(); + ByteString aStr; + aStr="Id "; + aStr+=ByteString::CreateFromInt32(nId); + aStr+=" only handled by SimpleErrorHandler"; + aStr+="\nErrorCode: "; + aStr+=ByteString::CreateFromInt32(nId & ((1L << ERRCODE_CLASS_SHIFT) - 1 )); + aStr+="\nErrorClass: "; + aStr+=ByteString::CreateFromInt32((nId & ERRCODE_CLASS_MASK) >> ERRCODE_CLASS_SHIFT); + aStr+="\nErrorArea: "; + aStr+=ByteString::CreateFromInt32((nId & ERRCODE_ERROR_MASK & + ~((1 << ERRCODE_AREA_SHIFT ) -1 ) ) >> ERRCODE_AREA_SHIFT); + DynamicErrorInfo *pDyn=PTR_CAST(DynamicErrorInfo,pInfo); + if(pDyn) + { + aStr+="\nDId "; + aStr+=ByteString::CreateFromInt32((ULONG)*pDyn); + } + StandardErrorInfo *pStd=PTR_CAST(StandardErrorInfo,pInfo); + if(pStd) + { + aStr+="\nXId "; + aStr+=ByteString::CreateFromInt32(pStd->GetExtendedErrorCode()); + } + rStr = String( aStr, RTL_TEXTENCODING_ASCII_US ); + return TRUE; +} + +SimpleErrorHandler::SimpleErrorHandler() + : ErrorHandler() +{ +} + diff --git a/tools/source/ref/globname.cxx b/tools/source/ref/globname.cxx new file mode 100644 index 000000000000..f19c0e5fa805 --- /dev/null +++ b/tools/source/ref/globname.cxx @@ -0,0 +1,441 @@ +/************************************************************************* + * + * $RCSfile: globname.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:08 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <ctype.h> +#include <stdio.h> +#include <string.h> + +#include <stream.hxx> +#include <globname.hxx> + +#pragma hdrstop + +/************** class ImpSvGlobalName ************************************/ +ImpSvGlobalName::ImpSvGlobalName( const ImpSvGlobalName & rObj ) +{ + nRefCount = 0; + memcpy( szData, rObj.szData, sizeof( szData ) ); +} + +/************** class ImpSvGlobalName ************************************/ +ImpSvGlobalName::ImpSvGlobalName( int ) +{ + nRefCount = 1; + memset( szData, 0, sizeof( szData ) ); +} + +/************************************************************************* +|* ImpSvGlobalName::operator ==() +*************************************************************************/ +BOOL ImpSvGlobalName::operator == ( const ImpSvGlobalName & rObj ) const +{ + return !memcmp( szData, rObj.szData, sizeof( szData ) ); +} + +/************************************************************************* +|* SvGlobalName::SvGlobalName() +*************************************************************************/ +SvGlobalName::SvGlobalName() +{ + static ImpSvGlobalName aNoName( 0 ); + + pImp = &aNoName; + pImp->nRefCount++; +} + +// locker die Struktur von Windows kopiert +#ifdef WNT +struct _GUID +#else +struct GUID +#endif +{ + UINT32 Data1; + UINT16 Data2; + UINT16 Data3; + BYTE Data4[8]; +}; +SvGlobalName::SvGlobalName( const CLSID & rId ) +{ + pImp = new ImpSvGlobalName(); + pImp->nRefCount++; + memcpy( pImp->szData, &rId, sizeof( pImp->szData ) ); +} + +SvGlobalName::SvGlobalName( UINT32 n1, USHORT n2, USHORT n3, + BYTE b8, BYTE b9, BYTE b10, BYTE b11, + BYTE b12, BYTE b13, BYTE b14, BYTE b15 ) +{ + pImp = new ImpSvGlobalName(); + pImp->nRefCount++; + + *(UINT32 *)pImp->szData = n1; + *(USHORT *)&pImp->szData[ 4 ] = n2; + *(USHORT *)&pImp->szData[ 6 ] = n3; + pImp->szData[ 8 ] = b8; + pImp->szData[ 9 ] = b9; + pImp->szData[ 10 ] = b10; + pImp->szData[ 11 ] = b11; + pImp->szData[ 12 ] = b12; + pImp->szData[ 13 ] = b13; + pImp->szData[ 14 ] = b14; + pImp->szData[ 15 ] = b15; +} + +/************************************************************************* +|* SvGlobalName::~SvGlobalName() +*************************************************************************/ +SvGlobalName::~SvGlobalName() +{ + pImp->nRefCount--; + if( !pImp->nRefCount ) + delete pImp; +} + +/************************************************************************* +|* SvGlobalName::operator = () +*************************************************************************/ +SvGlobalName & SvGlobalName::operator = ( const SvGlobalName & rObj ) +{ + rObj.pImp->nRefCount++; + pImp->nRefCount--; + if( !pImp->nRefCount ) + delete pImp; + pImp = rObj.pImp; + return *this; +} + +/************************************************************************* +|* SvGlobalName::NewImp() +*************************************************************************/ +void SvGlobalName::NewImp() +{ + if( pImp->nRefCount > 1 ) + { + pImp->nRefCount--; + pImp = new ImpSvGlobalName( *pImp ); + pImp->nRefCount++; + } +} + +/************************************************************************* +|* SvGlobalName::operator << () +|* SvGlobalName::operator >> () +*************************************************************************/ +SvStream& operator << ( SvStream& rOStr, const SvGlobalName & rObj ) +{ + rOStr << *(UINT32 *)rObj.pImp->szData; + rOStr << *(USHORT *)&rObj.pImp->szData[ 4 ]; + rOStr << *(USHORT *)&rObj.pImp->szData[ 6 ]; + rOStr.Write( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 ); + return rOStr; +} + +SvStream& operator >> ( SvStream& rStr, SvGlobalName & rObj ) +{ + rObj.NewImp(); // kopieren, falls noetig + rStr >> *(UINT32 *)rObj.pImp->szData; + rStr >> *(USHORT *)&rObj.pImp->szData[ 4 ]; + rStr >> *(USHORT *)&rObj.pImp->szData[ 6 ]; + rStr.Read( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 ); + return rStr; +} + + +/************************************************************************* +|* SvGlobalName::operator < () +*************************************************************************/ +BOOL SvGlobalName::operator < ( const SvGlobalName & rObj ) const +{ + int n = memcmp( pImp->szData +6, rObj.pImp->szData +6, + sizeof( pImp->szData ) -6); + if( n < 0 ) + return TRUE; + else if( n > 0 ) + return FALSE; + else if( *(USHORT *)&pImp->szData[ 4 ] < *(USHORT *)&rObj.pImp->szData[ 4 ] ) + return TRUE; + else if( *(USHORT *)&pImp->szData[ 4 ] == *(USHORT *)&rObj.pImp->szData[ 4 ] ) + return *(UINT32 *)pImp->szData < *(UINT32 *)rObj.pImp->szData; + else + return FALSE; + +} + +/************************************************************************* +|* SvGlobalName::operator +=() +*************************************************************************/ +SvGlobalName & SvGlobalName::operator += ( UINT32 n ) +{ + NewImp(); + UINT32 nOld = (*(UINT32 *)pImp->szData); + (*(UINT32 *)pImp->szData) += n; + if( nOld > *(UINT32 *)pImp->szData ) + // ueberlauf + (*(USHORT *)&pImp->szData[ 4 ])++; + return *this; +} + +/************************************************************************* +|* SvGlobalName::operator ==() +*************************************************************************/ +BOOL SvGlobalName::operator == ( const SvGlobalName & rObj ) const +{ + return *pImp == *rObj.pImp; +} + +void SvGlobalName::MakeFromMemory( void * pData ) +{ + NewImp(); + memcpy( pImp->szData, pData, sizeof( pImp->szData ) ); +} + +/************************************************************************* +|* SvGlobalName::MakeId() +*************************************************************************/ +BOOL SvGlobalName::MakeId( const String & rIdStr ) +{ + ByteString aStr( rIdStr, RTL_TEXTENCODING_ASCII_US ); + sal_Char * pStr = (sal_Char *)aStr.GetBuffer(); + if( rIdStr.Len() == 36 + && '-' == pStr[ 8 ] && '-' == pStr[ 13 ] + && '-' == pStr[ 18 ] && '-' == pStr[ 23 ] ) + { + UINT32 nFirst = 0; + int i = 0; + for( i = 0; i < 8; i++ ) + { + if( isxdigit( *pStr ) ) + if( isdigit( *pStr ) ) + nFirst = nFirst * 16 + (*pStr - '0'); + else + nFirst = nFirst * 16 + (toupper( *pStr ) - 'A' + 10 ); + else + return FALSE; + pStr++; + } + + UINT16 nSec = 0; + pStr++; + for( i = 0; i < 4; i++ ) + { + if( isxdigit( *pStr ) ) + if( isdigit( *pStr ) ) + nSec = nSec * 16 + (*pStr - '0'); + else + nSec = nSec * 16 + (toupper( *pStr ) - 'A' + 10 ); + else + return FALSE; + pStr++; + } + + UINT16 nThird = 0; + pStr++; + for( i = 0; i < 4; i++ ) + { + if( isxdigit( *pStr ) ) + if( isdigit( *pStr ) ) + nThird = nThird * 16 + (*pStr - '0'); + else + nThird = nThird * 16 + (toupper( *pStr ) - 'A' + 10 ); + else + return FALSE; + pStr++; + } + + BYTE szRemain[ 8 ]; + memset( szRemain, 0, sizeof( szRemain ) ); + pStr++; + for( i = 0; i < 16; i++ ) + { + if( isxdigit( *pStr ) ) + if( isdigit( *pStr ) ) + szRemain[i/2] = szRemain[i/2] * 16 + (*pStr - '0'); + else + szRemain[i/2] = szRemain[i/2] * 16 + (toupper( *pStr ) - 'A' + 10 ); + else + return FALSE; + pStr++; + if( i == 3 ) + pStr++; + } + + NewImp(); + *(UINT32 *)pImp->szData = nFirst; + *(USHORT *)&pImp->szData[ 4 ] = nSec; + *(USHORT *)&pImp->szData[ 6 ] = nThird; + memcpy( &pImp->szData[ 8 ], szRemain, 8 ); + return TRUE; + } + return FALSE; +} + +/************************************************************************* +|* SvGlobalName::GetctorName() +*************************************************************************/ +String SvGlobalName::GetctorName() const +{ + ByteString aRet; + + sal_Char buf[ 20 ]; + sprintf( buf, "0x%8.8lX", (ULONG)*(UINT32 *)pImp->szData ); + aRet += buf; + USHORT i; + for( i = 4; i < 8; i += 2 ) + { + aRet += ','; + sprintf( buf, "0x%4.4X", *(USHORT *)&pImp->szData[ i ] ); + aRet += buf; + } + for( i = 8; i < 16; i++ ) + { + aRet += ','; + sprintf( buf, "0x%2.2x", pImp->szData[ i ] ); + aRet += buf; + } + return String( aRet, RTL_TEXTENCODING_ASCII_US ); +} + +/************************************************************************* +|* SvGlobalName::GetHexName() +*************************************************************************/ +String SvGlobalName::GetHexName() const +{ + ByteString aRet; + + sal_Char buf[ 10 ]; + sprintf( buf, "%8.8lX", (ULONG)*(UINT32 *)pImp->szData ); + aRet += buf; + aRet += '-'; + USHORT i ; + for( i = 4; i < 8; i += 2 ) + { + sprintf( buf, "%4.4X", *(USHORT *)&pImp->szData[ i ] ); + aRet += buf; + aRet += '-'; + } + for( i = 8; i < 10; i++ ) + { + sprintf( buf, "%2.2x", pImp->szData[ i ] ); + aRet += buf; + } + aRet += '-'; + for( i = 10; i < 16; i++ ) + { + sprintf( buf, "%2.2x", pImp->szData[ i ] ); + aRet += buf; + } + return String( aRet, RTL_TEXTENCODING_ASCII_US ); +} + +/************** SvGlobalNameList ****************************************/ +/************************************************************************/ +/************************************************************************* +|* SvGlobalNameList::SvGlobalNameList() +*************************************************************************/ +SvGlobalNameList::SvGlobalNameList() + : aList( 1, 1 ) +{ +} + +/************************************************************************* +|* SvGlobalNameList::~SvGlobalNameList() +*************************************************************************/ +SvGlobalNameList::~SvGlobalNameList() +{ + for( ULONG i = Count(); i > 0; i-- ) + { + ImpSvGlobalName * pImp = (ImpSvGlobalName *)aList.GetObject( i -1 ); + pImp->nRefCount--; + if( !pImp->nRefCount ) + delete pImp; + } +} + +/************************************************************************* +|* SvGlobalNameList::Append() +*************************************************************************/ +void SvGlobalNameList::Append( const SvGlobalName & rName ) +{ + rName.pImp->nRefCount++; + aList.Insert( rName.pImp, LIST_APPEND ); +} + +/************************************************************************* +|* SvGlobalNameList::GetObject() +*************************************************************************/ +SvGlobalName SvGlobalNameList::GetObject( ULONG nPos ) +{ + return SvGlobalName( (ImpSvGlobalName *)aList.GetObject( nPos ) ); +} + +/************************************************************************* +|* SvGlobalNameList::IsEntry() +*************************************************************************/ +BOOL SvGlobalNameList::IsEntry( const SvGlobalName & rName ) +{ + for( ULONG i = Count(); i > 0; i-- ) + { + if( *rName.pImp == *(ImpSvGlobalName *)aList.GetObject( i -1 ) ) + return TRUE; + } + return FALSE; +} diff --git a/tools/source/ref/makefile.mk b/tools/source/ref/makefile.mk new file mode 100644 index 000000000000..ad85f0accd62 --- /dev/null +++ b/tools/source/ref/makefile.mk @@ -0,0 +1,90 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=ref + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/ref.obj \ + $(SLO)$/pstm.obj \ + $(SLO)$/globname.obj \ + $(SLO)$/errinf.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/ref.obj \ + $(OBJ)$/pstm.obj \ + $(OBJ)$/globname.obj \ + $(OBJ)$/errinf.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/ref/pstm.cxx b/tools/source/ref/pstm.cxx new file mode 100644 index 000000000000..93ba671a2da1 --- /dev/null +++ b/tools/source/ref/pstm.cxx @@ -0,0 +1,945 @@ +/************************************************************************* + * + * $RCSfile: pstm.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <debug.hxx> +#include <pstm.hxx> + +#pragma hdrstop + +#define STOR_NO_OPTIMIZE + +/***********************************************************************/ +/************************************************************************ +|* SvClassManager::Register() +*************************************************************************/ +void SvClassManager::Register( USHORT nClassId, SvCreateInstancePersist pFunc ) +{ +#ifdef DBG_UTIL + SvCreateInstancePersist p; + p = (SvCreateInstancePersist)aAssocTable.Get( nClassId ); + DBG_ASSERT( !p || p == pFunc, "register class with same id" ) +#endif + aAssocTable.Insert( nClassId, (void *)pFunc ); +} + +/************************************************************************ +|* SvClassManager::Get() +*************************************************************************/ +SvCreateInstancePersist SvClassManager::Get( USHORT nClassId ) +{ + return (SvCreateInstancePersist)aAssocTable.Get( nClassId ); +} + +/****************** SvRttiBase *******************************************/ +TYPEINIT0( SvRttiBase ); + +/****************** SvPersistBaseMemberList ******************************/ +#define inline +SV_IMPL_REF_LIST(SuperSvPersistBase,SuperSvPersistBase*) +#undef inline + +#define PERSIST_LIST_VER (BYTE)0 +#define PERSIST_LIST_DBGUTIL (BYTE)0x80 + +/************************************************************************ +|* SvPersistBaseMemberList::WriteOnlyStreamedObjects() +*************************************************************************/ +void SvPersistBaseMemberList::WriteObjects( SvPersistStream & rStm, + BOOL bOnlyStreamed ) const +{ +#ifdef STOR_NO_OPTIMIZE + rStm << (BYTE)(PERSIST_LIST_VER | PERSIST_LIST_DBGUTIL); + UINT32 nObjPos = rStm.WriteDummyLen(); +#else + BYTE bTmp = PERSIST_LIST_VER; + rStm << bTmp; +#endif + UINT32 nCount = Count(); + ULONG nCountPos = rStm.Tell(); + UINT32 nWriteCount = 0; + rStm << nCount; + //bloss die Liste nicht veraendern, + //wegen Seiteneffekten beim Save + for( ULONG n = 0; n < nCount; n++ ) + { + SvPersistBase * pObj = GetObject( n ); + if( !bOnlyStreamed || rStm.IsStreamed( pObj ) ) + { // Objekt soll geschrieben werden + rStm << GetObject( n ); + nWriteCount++; + } + } + if( nWriteCount != nCount ) + { + // nicht alle Objekte geschrieben, Count anpassen + ULONG nPos = rStm.Tell(); + rStm.Seek( nCountPos ); + rStm << nWriteCount; + rStm.Seek( nPos ); + } +#ifdef STOR_NO_OPTIMIZE + rStm.WriteLen( nObjPos ); +#endif +} + +/************************************************************************ +|* operator << () +*************************************************************************/ +SvPersistStream& operator << ( SvPersistStream & rStm, + const SvPersistBaseMemberList & rLst ) +{ + rLst.WriteObjects( rStm ); + return rStm; +} + +/************************************************************************ +|* operator >> () +*************************************************************************/ +SvPersistStream& operator >> ( SvPersistStream & rStm, + SvPersistBaseMemberList & rLst ) +{ + BYTE nVer; + rStm >> nVer; + + if( (nVer & ~PERSIST_LIST_DBGUTIL) != PERSIST_LIST_VER ) + { + rStm.SetError( SVSTREAM_GENERALERROR ); + DBG_ERROR( "persist list, false version" ) + } + + UINT32 nObjLen, nObjPos; + if( nVer & PERSIST_LIST_DBGUTIL ) + nObjLen = rStm.ReadLen( &nObjPos ); + + ULONG nCount; + rStm >> nCount; + for( ULONG n = 0; n < nCount && rStm.GetError() == SVSTREAM_OK; n++ ) + { + SvPersistBase * pObj; + rStm >> pObj; + if( pObj ) + rLst.Append( pObj ); + } +#ifdef DBG_UTIL + if( nObjLen + nObjPos != rStm.Tell() ) + { + ByteString aStr( "false list len: read = " ); + aStr += ByteString::CreateFromInt32( (long)(rStm.Tell() - nObjPos) ); + aStr += ", should = "; + aStr += nObjLen; + DBG_ERROR( aStr.GetBuffer() ) + } +#endif + return rStm; +} + +//========================================================================= +SvPersistStream::SvPersistStream +( + SvClassManager & rMgr, /* Alle Factorys, deren Objekt geladen und + gespeichert werdn k"onnen */ + SvStream * pStream, /* Dieser Stream wird als Medium genommen, auf + dem der PersistStream arbeitet */ + UINT32 nStartIdxP /* Ab diesem Index werden die Id's f"ur + die Objekte vergeben, er muss gr"osser + als Null sein. */ +) + : rClassMgr( rMgr ) + , pStm( pStream ) + , aPUIdx( nStartIdxP ) + , nStartIdx( nStartIdxP ) + , pRefStm( NULL ) + , nFlags( 0 ) +/* [Beschreibung] + + Der Konstruktor der Klasse SvPersistStream. Die Objekte rMgr und + pStream d"urfen nicht ver"andert werden, solange sie in einem + SvPersistStream eingesetzt sind. Eine Aussnahme gibt es f"ur + pStream (siehe <SvPersistStream::SetStream>). +*/ +{ + DBG_ASSERT( nStartIdx != 0, "zero index not allowed" ) + bIsWritable = TRUE; + if( pStm ) + { + SetVersion( pStm->GetVersion() ); + SetError( pStm->GetError() ); + SyncSvStream( pStm->Tell() ); + } +} + +//========================================================================= +SvPersistStream::SvPersistStream +( + SvClassManager & rMgr, /* Alle Factorys, deren Objekt geladen und + gespeichert werdn k"onnen */ + SvStream * pStream, /* Dieser Stream wird als Medium genommen, auf + dem der PersistStream arbeitet */ + const SvPersistStream & rPersStm + /* Wenn PersistStream's verschachtelt werden, + dann ist dies der Parent-Stream. */ +) + : rClassMgr( rMgr ) + , pStm( pStream ) + // Bereiche nicht ueberschneiden, deshalb nur groessere Indexe + , aPUIdx( rPersStm.GetCurMaxIndex() +1 ) + , nStartIdx( rPersStm.GetCurMaxIndex() +1 ) + , pRefStm( &rPersStm ) + , nFlags( 0 ) +/* [Beschreibung] + + Der Konstruktor der Klasse SvPersistStream. Die Objekte rMgr und + pStream d"urfen nicht ver"andert werden, solange sie in einem + SvPersistStream eingesetzt sind. Eine Aussnahme gibt es f"ur + pStream (siehe <SvPersistStream::SetStream>). + Durch diesen Konstruktor wird eine Hierarchiebildung unterst"utzt. + Alle Objekte aus einer Hierarchie m"ussen erst geladen werden, + wenn das erste aus dieser Hierarchie benutzt werden soll. +*/ +{ + bIsWritable = TRUE; + if( pStm ) + { + SetVersion( pStm->GetVersion() ); + SetError( pStm->GetError() ); + SyncSvStream( pStm->Tell() ); + } +} + +//========================================================================= +SvPersistStream::~SvPersistStream() +/* [Beschreibung] + + Der Detruktor ruft die Methode <SvPersistStream::SetStream> + mit NULL. +*/ +{ + SetStream( NULL ); +} + +//========================================================================= +void SvPersistStream::SetStream +( + SvStream * pStream /* auf diesem Stream arbeitet der PersistStream */ + +) +/* [Beschreibung] + + Es wird ein Medium (pStream) eingesetzt, auf dem PersistStream arbeitet. + Dieses darf nicht von aussen modifiziert werden, solange es + eingesetzt ist. Es sei denn, w"ahrend auf dem Medium gearbeitet + wird, wird keine Methode von SvPersistStream gerufen, bevor + nicht <SvPersistStream::SetStream> mit demselben Medium gerufen + wurde. +*/ +{ + if( pStm != pStream ) + { + if( pStm ) + { + SyncSysStream(); + pStm->SetError( GetError() ); + } + pStm = pStream; + } + if( pStm ) + { + SetVersion( pStm->GetVersion() ); + SetError( pStm->GetError() ); + SyncSvStream( pStm->Tell() ); + } +} + +//========================================================================= +USHORT SvPersistStream::IsA() const +/* [Beschreibung] + + Gibt den Identifier dieses Streamklasse zur"uck. + + [R"uckgabewert] + + USHORT ID_PERSISTSTREAM wird zur"uckgegeben. + + + [Querverweise] + + <SvStream::IsA> +*/ +{ + return ID_PERSISTSTREAM; +} + + +/************************************************************************* +|* SvPersistStream::ResetError() +*************************************************************************/ +void SvPersistStream::ResetError() +{ + SvStream::ResetError(); + DBG_ASSERT( pStm, "stream not set" ) + pStm->ResetError(); +} + +/************************************************************************* +|* SvPersistStream::GetData() +*************************************************************************/ +ULONG SvPersistStream::GetData( void* pData, ULONG nSize ) +{ + DBG_ASSERT( pStm, "stream not set" ) + ULONG nRet = pStm->Read( pData, nSize ); + SetError( pStm->GetError() ); + return nRet; +} + +/************************************************************************* +|* SvPersistStream::PutData() +*************************************************************************/ +ULONG SvPersistStream::PutData( const void* pData, ULONG nSize ) +{ + DBG_ASSERT( pStm, "stream not set" ) + ULONG nRet = pStm->Write( pData, nSize ); + SetError( pStm->GetError() ); + return nRet; +} + +/************************************************************************* +|* SvPersistStream::Seek() +*************************************************************************/ +ULONG SvPersistStream::SeekPos( ULONG nPos ) +{ + DBG_ASSERT( pStm, "stream not set" ) + ULONG nRet = pStm->Seek( nPos ); + SetError( pStm->GetError() ); + return nRet; +} + +/************************************************************************* +|* SvPersistStream::FlushData() +*************************************************************************/ +void SvPersistStream::FlushData() +{ +} + +/************************************************************************* +|* SvPersistStream::GetCurMaxIndex() +*************************************************************************/ +ULONG SvPersistStream::GetCurMaxIndex( const SvPersistUIdx & rIdx ) const +{ + // const bekomme ich nicht den hoechsten Index + SvPersistUIdx * p = (SvPersistUIdx *)&rIdx; + // alten merken + ULONG nCurIdx = p->GetCurIndex(); + p->Last(); + // Bereiche nicht ueberschneiden, deshalb nur groessere Indexe + ULONG nMaxIdx = p->GetCurIndex(); + // wieder herstellen + p->Seek( nCurIdx ); + return nMaxIdx; +} + +/************************************************************************* +|* SvPersistStream::GetIndex() +*************************************************************************/ +ULONG SvPersistStream::GetIndex( SvPersistBase * pObj ) const +{ + ULONG nId = (ULONG)aPTable.Get( (ULONG)pObj ); + if( !nId && pRefStm ) + return pRefStm->GetIndex( pObj ); + return nId; +} + +/************************************************************************* +|* SvPersistStream::GetObject) +*************************************************************************/ +SvPersistBase * SvPersistStream::GetObject( ULONG nIdx ) const +{ + if( nIdx >= nStartIdx ) + return aPUIdx.Get( nIdx ); + else if( pRefStm ) + return pRefStm->GetObject( nIdx ); + return NULL; +} + +//========================================================================= +#define LEN_1 0x80 +#define LEN_2 0x40 +#define LEN_4 0x20 +#define LEN_5 0x10 +UINT32 SvPersistStream::ReadCompressed +( + SvStream & rStm /* Aus diesem Stream werden die komprimierten Daten + gelesen */ +) +/* [Beschreibung] + + Ein im Stream komprimiert abgelegtes Wort wird gelesen. In welchem + Format komprimiert wird, siehe <SvPersistStream::WriteCompressed>. + + [R"uckgabewert] + + UINT32 Das nicht komprimierte Wort wird zur"uckgegeben. + + [Querverweise] + +*/ +{ + UINT32 nRet; + BYTE nMask; + rStm >> nMask; + if( nMask & LEN_1 ) + nRet = ~LEN_1 & nMask; + else if( nMask & LEN_2 ) + { + nRet = ~LEN_2 & nMask; + nRet <<= 8; + rStm >> nMask; + nRet |= nMask; + } + else if( nMask & LEN_4 ) + { + nRet = ~LEN_4 & nMask; + nRet <<= 8; + rStm >> nMask; + nRet |= nMask; + nRet <<= 16; + USHORT n; + rStm >> n; + nRet |= n; + } + else if( nMask & LEN_5 ) + { + if( nMask & 0x0F ) + { + rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); + DBG_ERROR( "format error" ) + } + rStm >> nRet; + } + else + { + rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); + DBG_ERROR( "format error" ) + } + return nRet; +} + +//========================================================================= +void SvPersistStream::WriteCompressed +( + SvStream & rStm,/* Aus diesem Stream werden die komprimierten Daten + gelesen */ + UINT32 nVal /* Dieser Wert wird komprimiert geschrieben */ +) +/* [Beschreibung] + + Das "ubergebene Wort wird komprimiert und in den Stream + geschrieben. Folgendermassen wir komprimiert. + nVal < 0x80 => 0x80 + nVal ist 1 Byte gross. + nVal < 0x4000 => 0x4000 + nVal ist 2 Byte gross. + nVal < 0x20000000 => 0x20000000 + nVal ist 4 Byte gross. + nVal > 0x1FFFFFFF => 0x1000000000+ nVal ist 5 Byte gross. + + [Querverweise] + + <SvPersistStream::ReadCompressed> +*/ +{ +#ifdef STOR_NO_OPTIMIZE + if( nVal < 0x80 ) + rStm << (BYTE)(LEN_1 | nVal); + else if( nVal < 0x4000 ) + { + rStm << (BYTE)(LEN_2 | (nVal >> 8)); + rStm << (BYTE)nVal; + } + else if( nVal < 0x20000000 ) + { + // hoechstes BYTE + rStm << (BYTE)(LEN_4 | (nVal >> 24)); + // 2. hoechstes BYTE + rStm << (BYTE)(nVal >> 16); + rStm << (USHORT)(nVal); + } + else +#endif + { + rStm << (BYTE)LEN_5; + rStm << nVal; + } +} + +//========================================================================= +UINT32 SvPersistStream::WriteDummyLen() +/* [Beschreibung] + + Die Methode schreibt 4 Byte in den Stream und gibt die Streamposition + zur"uck. + + [R"uckgabewert] + + UINT32 Die Position hinter der L"angenangabe wird zur"uckgegeben. + + [Beispiel] + + UINT32 nObjPos = rStm.WriteDummyLen(); + ... + // Daten schreiben + ... + rStm.WriteLen( nObjPos ); + + [Querverweise] + + <SvPersistStream::ReadLen>, <SvPersistStream::WriteLen> + +*/ +{ +#ifdef DBG_UTIL + UINT32 nPos = Tell(); +#endif + UINT32 n0 = 0; + *this << n0; // wegen Sun sp + // keine Assertion bei Streamfehler + DBG_ASSERT( GetError() != SVSTREAM_OK + || (sizeof( UINT32 ) == Tell() -nPos), + "keine 4-Byte fuer Langenangabe" ); + return Tell(); +} + +//========================================================================= +void SvPersistStream::WriteLen +( + UINT32 nObjPos /* die Position + 4, an der die L"ange geschrieben + wird. */ +) +/* [Beschreibung] + + Die Methode schreibt die Differenz zwischen der aktuellen und + nObjPos als UINT32 an die Position nObjPos -4 im Stream. Danach + wird der Stream wieder auf die alte Position gestellt. + + [Beispiel] + + Die Differenz enth"alt nicht die L"angenangabe. + + UINT32 nObjPos = rStm.WriteDummyLen(); + ... + // Daten schreiben + ... + rStm.WriteLen( nObjPos ); + // weitere Daten schreiben + + [Querverweise] + + <SvPersistStream::ReadLen>, <SvPersistStream::WriteDummyLen> +*/ +{ + UINT32 nPos = Tell(); + UINT32 nLen = nPos - nObjPos; + // die Laenge muá im stream 4-Byte betragen + Seek( nObjPos - sizeof( UINT32 ) ); + // Laenge schreiben + *this << nLen; + Seek( nPos ); +} + +//========================================================================= +UINT32 SvPersistStream::ReadLen +( + UINT32 * pTestPos /* Die Position des Streams, nach dem Lesen der + L"ange, wird zur"uckgegeben. Es darf auch NULL + "ubergeben werden. */ +) +/* [Beschreibung] + + Liest die L"ange die vorher mit <SvPersistStream::WriteDummyLen> + und <SvPersistStream::WriteLen> geschrieben wurde. +*/ +{ + UINT32 nLen; + *this >> nLen; + if( pTestPos ) + *pTestPos = Tell(); + return nLen; +} + +//========================================================================= +// Dateirormat abw"arts kompatibel +#ifdef STOR_NO_OPTIMIZE +#define P_VER (BYTE)0x00 +#else +#define P_VER (BYTE)0x01 +#endif +#define P_VER_MASK (BYTE)0x0F +#define P_ID_0 (BYTE)0x80 +#define P_OBJ (BYTE)0x40 +#define P_DBGUTIL (BYTE)0x20 +#define P_ID (BYTE)0x10 +#ifdef STOR_NO_OPTIMIZE +#define P_STD P_DBGUTIL +#else +#define P_STD 0 +#endif + +static void WriteId +( + SvStream & rStm, + BYTE nHdr, + UINT32 nId, + USHORT nClassId +) +{ +#ifdef STOR_NO_OPTIMIZE + nHdr |= P_ID; +#endif + nHdr |= P_VER; + if( nHdr & P_ID ) + { + if( (nHdr & P_OBJ) || nId != 0 ) + { // Id nur bei Zeiger, oder DBGUTIL + rStm << (BYTE)(nHdr); + SvPersistStream::WriteCompressed( rStm, nId ); + } + else + { // NULL Pointer + rStm << (BYTE)(nHdr | P_ID_0); + return; + } + } + else + rStm << nHdr; + + if( (nHdr & P_DBGUTIL) || (nHdr & P_OBJ) ) + // Objekte haben immer eine Klasse, + // Pointer nur bei DBG_UTIL und != NULL + SvPersistStream::WriteCompressed( rStm, nClassId ); +} + +//========================================================================= +static void ReadId +( + SvStream & rStm, + BYTE & nHdr, + UINT32 & nId, + USHORT & nClassId +) +{ + nClassId = 0; + rStm >> nHdr; + if( nHdr & P_ID_0 ) + nId = 0; + else + { + if( (nHdr & P_VER_MASK) == 0 ) + { + if( (nHdr & P_DBGUTIL) || !(nHdr & P_OBJ) ) + nId = SvPersistStream::ReadCompressed( rStm ); + else + nId = 0; + } + else if( nHdr & P_ID ) + nId = SvPersistStream::ReadCompressed( rStm ); + + if( (nHdr & P_DBGUTIL) || (nHdr & P_OBJ) ) + nClassId = (USHORT)SvPersistStream::ReadCompressed( rStm ); + } +} + +//========================================================================= +void SvPersistStream::WriteObj +( + BYTE nHdr, + SvPersistBase * pObj +) +{ +#ifdef STOR_NO_OPTIMIZE + UINT32 nObjPos; + if( nHdr & P_DBGUTIL ) + // Position fuer Laenge merken + nObjPos = WriteDummyLen(); +#endif + pObj->Save( *this ); +#ifdef STOR_NO_OPTIMIZE + if( nHdr & P_DBGUTIL ) + WriteLen( nObjPos ); +#endif +} + +//========================================================================= +SvPersistStream& SvPersistStream::WritePointer +( + SvPersistBase * pObj +) +{ + BYTE nP = P_STD; + + if( pObj ) + { + ULONG nId = GetIndex( pObj ); + if( nId ) + nP |= P_ID; + else + { + nId = aPUIdx.Insert( pObj ); + aPTable.Insert( (ULONG)pObj, (void *)nId ); + nP |= P_OBJ; + } + WriteId( *this, nP, nId, pObj->GetClassId() ); + if( nP & P_OBJ ) + WriteObj( nP, pObj ); + } + else + { // NULL Pointer + WriteId( *this, nP | P_ID, 0, 0 ); + } + return *this; +} + +//========================================================================= +UINT32 SvPersistStream::ReadObj +( + SvPersistBase * & rpObj, + BOOL bRegister +) +{ + BYTE nHdr; + UINT32 nId = 0; + USHORT nClassId; + + rpObj = NULL; // Spezifikation: Im Fehlerfall 0. + ReadId( *this, nHdr, nId, nClassId ); + + // reine Versionsnummer durch maskieren + if( P_VER < (nHdr & P_VER_MASK) ) + { + SetError( SVSTREAM_FILEFORMAT_ERROR ); + DBG_ERROR( "false version" ) + } + + if( !(nHdr & P_ID_0) && GetError() == SVSTREAM_OK ) + { + if( P_OBJ & nHdr ) + { // read object, nId nur bei P_DBGUTIL gesetzt + DBG_ASSERT( !(nHdr & P_DBGUTIL) || NULL == aPUIdx.Get( nId ), + "object already exist" ) + SvCreateInstancePersist pFunc = rClassMgr.Get( nClassId ); + + UINT32 nObjLen, nObjPos; + if( nHdr & P_DBGUTIL ) + nObjLen = ReadLen( &nObjPos ); + if( !pFunc ) + { +#ifdef DBG_UTIL + ByteString aStr( "no class with id: " ); + aStr += ByteString::CreateFromInt32( nClassId ); + aStr += " registered"; + DBG_WARNING( aStr.GetBuffer() ); +#endif + SetError( ERRCODE_IO_NOFACTORY ); + return 0; + } + pFunc( &rpObj ); + // Sichern + rpObj->AddRef(); + + if( bRegister ) + { + // unbedingt erst in Tabelle eintragen + ULONG nNewId = aPUIdx.Insert( rpObj ); + // um den gleichen Zustand, wie nach dem Speichern herzustellen + aPTable.Insert( (ULONG)rpObj, (void *)nNewId ); + DBG_ASSERT( !(nHdr & P_DBGUTIL) || nId == nNewId, + "read write id conflict: not the same" ) + } + // und dann Laden + rpObj->Load( *this ); +#ifdef DBG_UTIL + if( nObjLen + nObjPos != Tell() ) + { + ByteString aStr( "false object len: read = " ); + aStr += ByteString::CreateFromInt32( (long)(Tell() - nObjPos) ); + aStr += ", should = "; + aStr += ByteString::CreateFromInt32( nObjLen ); + DBG_ERROR( aStr.GetBuffer() ) + } +#endif + rpObj->RestoreNoDelete(); + rpObj->ReleaseRef(); + } + else + { + rpObj = GetObject( nId ); + DBG_ASSERT( rpObj != NULL, "object does not exist" ) + DBG_ASSERT( rpObj->GetClassId() == nClassId, "class mismatch" ) + } + } + return nId; +} + +//========================================================================= +SvPersistStream& SvPersistStream::ReadPointer +( + SvPersistBase * & rpObj +) +{ + ReadObj( rpObj, TRUE ); + return *this; +} + +//========================================================================= +SvPersistStream& operator << +( + SvPersistStream & rStm, + SvPersistBase * pObj +) +{ + return rStm.WritePointer( pObj ); +} + +//========================================================================= +SvPersistStream& operator >> +( + SvPersistStream & rStm, + SvPersistBase * & rpObj +) +{ + return rStm.ReadPointer( rpObj ); +} + +//========================================================================= +SvStream& operator << +( + SvStream & rStm, + SvPersistStream & rThis +) +{ + SvStream * pOldStm = rThis.GetStream(); + rThis.SetStream( &rStm ); + + BYTE bTmp = 0; + rThis << bTmp; // Version + UINT32 nCount = (UINT32)rThis.aPUIdx.Count(); + rThis << nCount; + SvPersistBase * pEle = rThis.aPUIdx.First(); + for( UINT32 i = 0; i < nCount; i++ ) + { + BYTE nP = P_OBJ | P_ID | P_STD; + WriteId( rThis, nP, rThis.aPUIdx.GetCurIndex(), + pEle->GetClassId() ); + rThis.WriteObj( nP, pEle ); + pEle = rThis.aPUIdx.Next(); + } + rThis.SetStream( pOldStm ); + return rStm; +} + +//========================================================================= +SvStream& operator >> +( + SvStream & rStm, + SvPersistStream & rThis +) +{ + SvStream * pOldStm = rThis.GetStream(); + rThis.SetStream( &rStm ); + + BYTE nVers; + rThis >> nVers; // Version + if( 0 == nVers ) + { + UINT32 nCount = 0; + rThis >> nCount; + for( UINT32 i = 0; i < nCount; i++ ) + { + SvPersistBase * pEle; + // Lesen, ohne in die Tabellen einzutragen + UINT32 nId = rThis.ReadObj( pEle, FALSE ); + if( rThis.GetError() ) + break; + + // Die Id eines Objektes wird nie modifiziert + rThis.aPUIdx.Insert( nId, pEle ); + rThis.aPTable.Insert( (ULONG)pEle, (void *)nId ); + } + } + else + rThis.SetError( SVSTREAM_FILEFORMAT_ERROR ); + + rThis.SetStream( pOldStm ); + return rStm; +} + +//========================================================================= +ULONG SvPersistStream::InsertObj( SvPersistBase * pObj ) +{ + ULONG nId = aPUIdx.Insert( pObj ); + aPTable.Insert( (ULONG)pObj, (void *)nId ); + return nId; +} + +//========================================================================= +ULONG SvPersistStream::RemoveObj( SvPersistBase * pObj ) +{ + ULONG nIdx = GetIndex( pObj ); + aPUIdx.Remove( nIdx ); + aPTable.Remove( (ULONG)pObj ); + return nIdx; +} + diff --git a/tools/source/ref/ref.cxx b/tools/source/ref/ref.cxx new file mode 100644 index 000000000000..bfaa76fe9641 --- /dev/null +++ b/tools/source/ref/ref.cxx @@ -0,0 +1,90 @@ +/************************************************************************* + * + * $RCSfile: ref.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <ref.hxx> +#pragma hdrstop + +/****************** SvRefBaseMemberList **********************************/ +#define inline +SV_IMPL_REF_LIST( SvRefBase,SvRefBase* ) +#undef inline + +/************************************************************************** +#* SvRefBase::~SvRefBase() +**************************************************************************/ +SvRefBase::~SvRefBase() +{ +} + +/************************************************************************** +#* SvRefBase::QueryDelete() +**************************************************************************/ +void SvRefBase::QueryDelete() +{ + nRefCount = SV_NO_DELETE_REFCOUNT / 2; + delete this; +} + +SvCompatRefBase::~SvCompatRefBase() +{ + (*pFunc)( pObj ); +} + diff --git a/tools/source/solar/makefile.mk b/tools/source/solar/makefile.mk new file mode 100644 index 000000000000..f38364e9f623 --- /dev/null +++ b/tools/source/solar/makefile.mk @@ -0,0 +1,100 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=mksvconf +TARGETTYPE=CUI + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +CFILES= solar.c + +OBJFILES= $(OBJ)$/solar.obj + +APP1TARGET= $(TARGET) +APP1OBJS= $(OBJFILES) +APP1STDLIBS= +APP1DEPN= +APP1DEF= + +.IF "$(depend)" == "" +ALL: \ + $(INCCOM)$/svconf.h \ + ALLTAR + +$(INCCOM)$/svconf.h : $(BIN)$/$(TARGET) + $(BIN)$/$(TARGET) $@ + +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk + diff --git a/tools/source/solar/solar.c b/tools/source/solar/solar.c new file mode 100644 index 000000000000..a119ce84304d --- /dev/null +++ b/tools/source/solar/solar.c @@ -0,0 +1,590 @@ +/************************************************************************* + * + * $RCSfile: solar.c,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +#include <stdio.h> + +#ifdef UNX + +#include <unistd.h> +#include <sys/types.h> + +#ifdef HPUX +#include <stdlib.h> +#endif + +#define I_STDARG +#ifdef I_STDARG +#include <stdarg.h> +#else +#include <varargs.h> +#endif + +#define NO_USE_FORK_TO_CHECK +#ifdef USE_FORK_TO_CHECK +#include <sys/wait.h> +#else +#include <signal.h> +#include <setjmp.h> +#endif + +#else +#endif + +#define printTypeSize(Type,Name) printf( "sizeof(%s)\t= %d\n", Name, sizeof (Type) ) + +#define isSignedType(Type) (((Type)-1) < 0) +#define printTypeSign(Type,Name) printf( "%s\t= %s %s\n", Name, ( isSignedType(Type) ? "signed" : "unsigned" ), Name ) + + +/************************************************************************* +|* +|* IsBigEndian() +|* +|* Beschreibung True, wenn CPU BigEndian ist +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int IsBigEndian() +{ + long l = 1; + return ! *(char*)&l; +} + +/************************************************************************* +|* +|* IsStackGrowingDown() +|* +|* Beschreibung True, wenn der Stack nach unten waechst +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int IsStackGrowingDown_2( int * pI ) +{ + int i = 1; + return ((unsigned long)&i) < (unsigned long)pI; +} + +int IsStackGrowingDown() +{ + int i = 1; + return IsStackGrowingDown_2(&i); +} + +/************************************************************************* +|* +|* IsStackGrowingDown() +|* +|* Beschreibung Alignment von char Parametern, die (hoffentlich) +|* ueber den Stack uebergeben werden +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... ) +{ + if ( IsStackGrowingDown() ) + return &c - &b; + else + return &b - &c; +} + +int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c ) +{ + if ( IsStackGrowingDown() ) + return &c - &b; + else + return &b - &c; +} + +int GetStackAlignment() +{ + int nStackAlignment = GetStackAlignment_3(0,1,2,3,4,5); + if ( nStackAlignment != GetStackAlignment_2(0,1,2,3,4,5) ) + printf( "Pascal calling convention\n" ); + return nStackAlignment; +} + + +/************************************************************************* +|* +|* Typdeclarations for memory access test functions +|* +*************************************************************************/ +typedef enum { t_char, t_short, t_int, t_long, t_double } Type; +typedef int (*TestFunc)( Type, void* ); + + +#ifdef UNX + +/************************************************************************* +|* +|* PrintArgs() +|* +|* Beschreibung Testfunktion fuer variable Parameter +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +#ifdef I_STDARG +void PrintArgs( int p, ... ) +#else +void PrintArgs( p, va_alist ) +int p; +va_dcl +#endif +{ + int value; + va_list ap; + +#ifdef I_STDARG + va_start( ap, p ); +#else + va_start( ap ); +#endif + + printf( "value = %d", p ); + + while ( ( value = va_arg(ap, int) ) != 0 ) + printf( " %d", value ); + + printf( "\n" ); + va_end(ap); +} + +#ifndef USE_FORK_TO_CHECK +/************************************************************************* +|* +|* SignalHdl() +|* +|* Beschreibung faengt SIGBUS und SIGSEGV in check() ab +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +static jmp_buf check_env; +static int bSignal; +void SignalHdl( int sig ) +{ + bSignal = 1; + /* + fprintf( stderr, "Signal %d caught\n", sig ); + signal( sig, SignalHdl ); + /**/ + longjmp( check_env, sig ); +} +#endif + +/************************************************************************* +|* +|* check() +|* +|* Beschreibung Testet MemoryZugriff (read/write) +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int check( TestFunc func, Type eT, void* p ) +{ +#ifdef USE_FORK_TO_CHECK + pid_t nChild = fork(); + if ( nChild ) + { + int exitVal; + wait( &exitVal ); + if ( exitVal & 0xff ) + return -1; + else + return exitVal >> 8; + } + else + { + exit( func( eT, p ) ); + } +#else + int result; + + bSignal = 0; + + if ( !setjmp( check_env ) ) + { + signal( SIGSEGV, SignalHdl ); + signal( SIGBUS, SignalHdl ); + result = func( eT, p ); + signal( SIGSEGV, SIG_DFL ); + signal( SIGBUS, SIG_DFL ); + } + + if ( bSignal ) + return -1; + else + return 0; +#endif +} + +#endif + + +/************************************************************************* +|* +|* GetAtAddress() +|* +|* Beschreibung memory read access +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int GetAtAddress( Type eT, void* p ) +{ + switch ( eT ) + { + case t_char: return *((char*)p); + case t_short: return *((short*)p); + case t_int: return *((int*)p); + case t_long: return *((long*)p); + case t_double: return *((double*)p); + } + abort(); +} + +/************************************************************************* +|* +|* SetAtAddress() +|* +|* Beschreibung memory write access +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int SetAtAddress( Type eT, void* p ) +{ + switch ( eT ) + { + case t_char: return *((char*)p) = 0; + case t_short: return *((short*)p) = 0; + case t_int: return *((int*)p) = 0; + case t_long: return *((long*)p) = 0; + case t_double: return *((double*)p)= 0; + } + abort(); +} + +char* TypeName( Type eT ) +{ + switch ( eT ) + { + case t_char: return "char"; + case t_short: return "short"; + case t_int: return "int"; + case t_long: return "long"; + case t_double: return "double"; + } + abort(); +} + +/************************************************************************* +|* +|* Check(Get|Set)Access() +|* +|* Beschreibung Testet MemoryZugriff (read/write) +|* Zugriffsverletzungen werden abgefangen +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int CheckGetAccess( Type eT, void* p ) +{ + int b; + b = -1 != check( (TestFunc)GetAtAddress, eT, p ); +#ifdef DEBUG + fprintf( stderr, + "%s read %s at %p\n", + (b? "can" : "can not" ), TypeName(eT), p ); +#endif + return b; +} +int CheckSetAccess( Type eT, void* p ) +{ + int b; + b = -1 != check( (TestFunc)SetAtAddress, eT, p ); +#ifdef DEBUG + fprintf( stderr, + "%s write %s at %p\n", + (b? "can" : "can not" ), TypeName(eT), p ); +#endif + return b; +} + +/************************************************************************* +|* +|* GetAlignment() +|* +|* Beschreibung Bestimmt das Alignment verschiedener Typen +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +int GetAlignment( Type eT ) +{ + char a[ 16*8 ]; + long p = (long)(void*)a; + int i; + + /* clear a[...] to set legal value for double access */ + for ( i = 0; i < 16*8; i++ ) + a[i] = 0; + + p = ( p + 0xF ) & ~0xF; + for ( i = 1; i < 16; i++ ) + if ( CheckGetAccess( eT, (void*)(p+i) ) ) + return i; + return 0; +} + +/************************************************************************* +|* +|* struct Description +|* +|* Beschreibung Beschreibt die Parameter der Architektur +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +struct Description +{ + int bBigEndian; + int bStackGrowsDown; + int nStackAlignment; + int nAlignment[3]; /* 2,4,8 */ +}; + +/************************************************************************* +|* +|* Description_Ctor() +|* +|* Beschreibung Bestimmt die Parameter der Architektur +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +Description_Ctor( struct Description* pThis ) +{ + pThis->bBigEndian = IsBigEndian(); + pThis->bStackGrowsDown = IsStackGrowingDown(); + pThis->nStackAlignment = GetStackAlignment(); + + if ( sizeof(short) != 2 ) + abort(); + pThis->nAlignment[0] = GetAlignment( t_short ); + if ( sizeof(int) != 4 ) + abort(); + pThis->nAlignment[1] = GetAlignment( t_int ); + + if ( sizeof(long) == 8 ) + pThis->nAlignment[2] = GetAlignment( t_long ); + else if ( sizeof(double) == 8 ) + pThis->nAlignment[2] = GetAlignment( t_double ); + else + abort(); +} + +/************************************************************************* +|* +|* Description_Print() +|* +|* Beschreibung Schreibt die Parameter der Architektur als Header +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +Description_Print( struct Description* pThis, char* name ) +{ + int i; + FILE* f = fopen( name, "w" ); + fprintf( f, "#define __%s\n", + pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" ); + for ( i = 0; i < 3; i++ ) + fprintf( f, "#define __ALIGNMENT%d\t%d\n", + 1 << i+1, pThis->nAlignment[i] ); + fprintf( f, "#define __STACKALIGNMENT wird nicht benutzt\t%d\n", pThis->nStackAlignment ); + fprintf( f, "#define __STACKDIRECTION\t%d\n", + pThis->bStackGrowsDown ? -1 : 1 ); + fprintf( f, "#define __SIZEOFCHAR\t%d\n", sizeof( char ) ); + fprintf( f, "#define __SIZEOFSHORT\t%d\n", sizeof( short ) ); + fprintf( f, "#define __SIZEOFINT\t%d\n", sizeof( int ) ); + fprintf( f, "#define __SIZEOFLONG\t%d\n", sizeof( long ) ); + fprintf( f, "#define __SIZEOFPOINTER\t%d\n", sizeof( void* ) ); + fprintf( f, "#define __SIZEOFDOUBLE\t%d\n", sizeof( double ) ); + fprintf( f, "#define __IEEEDOUBLE\n" ); + fclose( f ); +} + +/************************************************************************* +|* +|* InfoMemoryAccess() +|* +|* Beschreibung Informeller Bytezugriffstest +|* +|* Ersterstellung EG 26.06.96 +|* Letzte Aenderung +|* +*************************************************************************/ +void InfoMemoryAccess( char* p ) +{ + if ( CheckGetAccess( t_char, p ) ) + printf( "can read address %p\n", p ); + else + printf( "can not read address %p\n", p ); + + if ( CheckSetAccess( t_char, p ) ) + printf( "can write address %p\n", p ); + else + printf( "can not write address %p\n", p ); +} + +/************************************************************************* +|* +|* InfoMemoryTypeAccess() +|* +|* Beschreibung Informeller Zugriffstest verschiedener Typen +|* +|* Ersterstellung EG 15.08.96 +|* Letzte Aenderung +|* +*************************************************************************/ +void InfoMemoryTypeAccess( Type eT ) +{ + char a[64]; + int i; + + /* clear a[...] to set legal value for double access */ + for ( i = 0; i < 64; i++ ) + a[i] = 0; + + for ( i = 56; i >= 7; i >>= 1 ) + { + printf( "Zugriff %s auf %i-Aligned Adresse : ", TypeName( eT ), i / 7 ); + printf( ( CheckGetAccess( eT, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) ); + } +} + +main( int argc, char* argv[] ) +{ + printTypeSign( char, "char" ); + printTypeSign( short, "short" ); + printTypeSign( int, "int" ); + printTypeSign( long, "long" ); + + printTypeSize( char, "char" ); + printTypeSize( short, "short" ); + printTypeSize( int, "int" ); + printTypeSize( long, "long" ); + printTypeSize( float, "float" ); + printTypeSize( double, "double" ); + printTypeSize( void *, "void *" ); + + if ( IsBigEndian() ) + printf( "BIGENDIAN (Sparc, MC680x0, RS6000, IP22, IP32, g3)\n" ); + else + printf( "LITTLEENDIAN (Intel, VAX, PowerPC)\n" ); + + if( IsStackGrowingDown() ) + printf( "Stack waechst nach unten\n" ); + else + printf( "Stack waechst nach oben\n" ); + + printf( "STACKALIGNMENT : %d\n", GetStackAlignment() ); + + /* PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ); */ + + if ( argc > 1 ) + { + struct Description description; + Description_Ctor( &description ); + Description_Print( &description, argv[1] ); + } + + { + char* p = NULL; + InfoMemoryAccess( p ); + p = (char*)&p; + InfoMemoryAccess( p ); + InfoMemoryTypeAccess( t_short ); + InfoMemoryTypeAccess( t_int ); + InfoMemoryTypeAccess( t_long ); + InfoMemoryTypeAccess( t_double ); + } + + exit( 0 ); +} diff --git a/tools/source/stream/cachestr.cxx b/tools/source/stream/cachestr.cxx new file mode 100644 index 000000000000..f4533f76515b --- /dev/null +++ b/tools/source/stream/cachestr.cxx @@ -0,0 +1,329 @@ +/************************************************************************* + * + * $RCSfile: cachestr.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <debug.hxx> +#include <stream.hxx> +#include <cachestr.hxx> +#include <tempfile.hxx> + +/************************************************************************* +|* +|* SvCacheStream::SvCacheStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +SvCacheStream::SvCacheStream( ULONG nMaxMemSize ) +{ + if( !nMaxMemSize ) +#if defined WIN || defined WNT || defined OS2 || defined MAC || defined UNX + nMaxMemSize = 20480; +#else + nMaxMemSize = 20480; +#endif + SvStream::bIsWritable = TRUE; + nMaxSize = nMaxMemSize; + bPersistent = FALSE; + pSwapStream = 0; + pCurrentStream = new SvMemoryStream( nMaxMemSize ); + pTempFile = 0; +} + +/************************************************************************* +|* +|* SvCacheStream::SvCacheStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +SvCacheStream::SvCacheStream( const String &rFileName, + ULONG nExpectedSize, + ULONG nMaxMemSize ) +{ + if( !nMaxMemSize ) +#if defined WIN || defined WNT || defined OS2 || defined MAC || defined UNX + nMaxMemSize = 20480; +#else + nMaxMemSize = 20480; +#endif + + if( nExpectedSize > nMaxMemSize ) + nExpectedSize = nMaxMemSize; // oder gleich in File schreiben + else if( !nExpectedSize ) + nExpectedSize = 4096; + + SvStream::bIsWritable = TRUE; + nMaxSize = nMaxMemSize; + bPersistent = TRUE; + aFileName = rFileName; + pSwapStream = 0; + pCurrentStream = new SvMemoryStream( nExpectedSize ); + pTempFile = 0; +} + +/************************************************************************* +|* +|* SvCacheStream::~SvCacheStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +SvCacheStream::~SvCacheStream() +{ + if( pCurrentStream != pSwapStream ) + delete pSwapStream; + delete pCurrentStream; + + if( pSwapStream && !bPersistent && pTempFile ) + { + // temporaeres File loeschen + pTempFile->EnableKillingFile( TRUE ); + } + + delete pTempFile; +} + +/************************************************************************* +|* +|* SvCacheStream::SwapOut() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +void SvCacheStream::SwapOut() +{ + if( pCurrentStream != pSwapStream ) + { + if( !pSwapStream && !aFileName.Len() ) + { + if (aFilenameLinkHdl.IsSet()) + { + // pSwapStream wird zum Schutz gegen Reentranz genutzt + pSwapStream = pCurrentStream; + Link aLink( aFilenameLinkHdl ); + aFilenameLinkHdl = Link(); + aLink.Call(this); + // pSwapStream nur zuruecksetzen, wenn nicht ueber + // SetSwapStream geaendert + if( pSwapStream == pCurrentStream ) pSwapStream = 0; + } + else + { + pTempFile = new TempFile; + aFileName = pTempFile->GetName(); + } + } + + ULONG nPos = pCurrentStream->Tell(); + pCurrentStream->Seek( 0 ); + if( !pSwapStream ) + pSwapStream = new SvFileStream( aFileName, STREAM_READWRITE | STREAM_TRUNC ); + *pSwapStream << *pCurrentStream; + pSwapStream->Flush(); + delete pCurrentStream; + pCurrentStream = pSwapStream; + pCurrentStream->Seek( nPos ); + } +} + +/************************************************************************* +|* +|* SvCacheStream::GetData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +ULONG SvCacheStream::GetData( void* pData, ULONG nSize ) +{ + return pCurrentStream->Read( pData, nSize ); +} + +/************************************************************************* +|* +|* SvCacheStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +ULONG SvCacheStream::PutData( const void* pData, ULONG nSize ) +{ + // lieber unnoetig auslagern als unnoetig umkopieren + if( pCurrentStream != pSwapStream + && pCurrentStream->Tell() + nSize > nMaxSize ) + SwapOut(); + return pCurrentStream->Write( pData, nSize ); +} + +/************************************************************************* +|* +|* SvCacheStream::SeekPos() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +ULONG SvCacheStream::SeekPos( ULONG nPos ) +{ + return pCurrentStream->Seek( nPos ); +} + +/************************************************************************* +|* +|* SvCacheStream::FlushData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +void SvCacheStream::FlushData() +{ + pCurrentStream->Flush(); + if( pCurrentStream != pSwapStream + && ((SvMemoryStream*)pCurrentStream)->GetSize() > nMaxSize ) + SwapOut(); +} + +/************************************************************************* +|* +|* SvCacheStream::GetStr() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +const void* SvCacheStream::GetBuffer() +{ + Flush(); + if( pCurrentStream != pSwapStream ) + return ((SvMemoryStream*)pCurrentStream)->GetData(); + else + return 0; +} + +/************************************************************************* +|* +|* SvCacheStream::SetSize() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +void SvCacheStream::SetSize( ULONG nSize ) +{ + pCurrentStream->SetStreamSize( nSize ); +} + +/************************************************************************* +|* +|* SvCacheStream::GetSize() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 27.09.94 +|* Letzte Aenderung OV 27.09.94 +|* +*************************************************************************/ + +ULONG SvCacheStream::GetSize() +{ + // ACHTUNG: SvMemoryStream::GetSize() gibt Groesse + // des allozierten Buffers zurueck + Flush(); + ULONG nTemp = Tell(); + ULONG nLength = Seek( STREAM_SEEK_TO_END ); + Seek( nTemp ); + return nLength; +} + +void SvCacheStream::SetFilenameHdl( const Link& rLink) +{ + aFilenameLinkHdl = rLink; +} + +const Link& SvCacheStream::GetFilenameHdl() const +{ + return aFilenameLinkHdl; +} diff --git a/tools/source/stream/makefile.mk b/tools/source/stream/makefile.mk new file mode 100644 index 000000000000..da71d3c408bc --- /dev/null +++ b/tools/source/stream/makefile.mk @@ -0,0 +1,103 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=stream + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/stream.obj \ + $(SLO)$/strmsys.obj \ + $(SLO)$/cachestr.obj \ + $(SLO)$/vcompat.obj + +.IF "$(UPDATER)" != "" +.IF "$(GUI)" != "MAC" +OBJFILES= $(OBJ)$/stdstrm.obj +.ENDIF + +OBJFILES+= $(OBJ)$/stream.obj \ + $(OBJ)$/strmsys.obj \ + $(OBJ)$/cachestr.obj \ + $(OBJ)$/vcompat.obj +.ENDIF + +# --- Targets ------------------------------------------------------- + +.INCLUDE : target.mk + +$(SLO)$/strmsys.obj : \ + strmos2.cxx \ + strmwnt.cxx \ + strmwin.cxx \ + strmmac.cxx \ + strmunx.cxx \ + strmstd.cxx + diff --git a/tools/source/stream/stream.cxx b/tools/source/stream/stream.cxx new file mode 100644 index 000000000000..adca76dfd39e --- /dev/null +++ b/tools/source/stream/stream.cxx @@ -0,0 +1,2905 @@ +/************************************************************************* + * + * $RCSfile: stream.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +// ToDo: +// - Read->RefreshBuffer->Auf Aenderungen von nBufActualLen reagieren + +#include <string.h> +#include <stdio.h> +#include <ctype.h> // isspace +#include <stdlib.h> // strtol, _crotl + +/* +#if defined( DBG_UTIL ) && defined( DEBUG ) +// prueft Synchronisation des Buffers nach allen Read, Write, Seek +#define OV_DEBUG +#endif +*/ + +#ifdef WIN +#include <dll.hxx> +#include <svwin.h> +#ifndef SEG +#define SEG(fp) (*((size_t*)&(fp) + 1)) +#endif +#include <solar.h> +#endif + +#if defined(BLC) +#define SWAPNIBBLES(c) c=_crotl(c,4); +#else +#define SWAPNIBBLES(c) \ +unsigned char nSwapTmp=c; \ +nSwapTmp <<= 4; \ +c >>= 4; \ +c |= nSwapTmp; +#endif + +#include <new.hxx> +#include <debug.hxx> +#define ENABLE_BYTESTRING_STREAM_OPERATORS +#include <stream.hxx> +#include <osl/thread.h> + +// ----------------------------------------------------------------------- + +DBG_NAME( Stream ); + +// ----------------------------------------------------------------------- + +// sprintf Param-Mode +#define SPECIAL_PARAM_NONE 0 // Format-Str, Number +#define SPECIAL_PARAM_WIDTH 1 // Format-Str, Width, Number +#define SPECIAL_PARAM_PRECISION 2 // Format-Str, Precision, Number +#define SPECIAL_PARAM_BOTH 3 // Format-Str, Width, Precision, Number + +#if SUPD <= 344 +#define _CR '\n' +#define _LF '\r' +#endif + +// ----------------------------------------------------------------------- + +// !!! Nicht inline, wenn Operatoren <<,>> inline sind +inline static void SwapUShort( USHORT& r ) + { r = SWAPSHORT(r); } +inline static void SwapShort( short& r ) + { r = SWAPSHORT(r); } +inline static void SwapInt( int& r ) + { r = SWAPSHORT(r); } +inline static void SwapUInt( unsigned int& r ) + { r = SWAPSHORT(r); } +inline static void SwapLong( long& r ) + { r = SWAPLONG(r); } +inline static void SwapULong( ULONG& r ) + { r = SWAPLONG(r); } +inline static void SwapLongInt( int& r ) + { r = SWAPLONG(r); } +inline static void SwapLongUInt( unsigned int& r ) + { r = SWAPLONG(r); } +#ifdef UNX +inline static void SwapFloat( float& r ) + { + DBG_ASSERT( FALSE, "SwapFloat noch nicht implementiert!\n" ); + } +inline static void SwapDouble( double& r ) + { + if( sizeof(double) != 8 ) + { + DBG_ASSERT( FALSE, "Can only swap 8-Byte-doubles\n" ); + } + else + { + UINT32* c = (UINT32*)(void*)&r; + c[0] ^= c[1]; // zwei 32-Bit-Werte in situ vertauschen + c[1] ^= c[0]; + c[0] ^= c[1]; + c[0] = SWAPLONG(c[0]); // und die beiden 32-Bit-Werte selbst in situ drehen + c[1] = SWAPLONG(c[1]); + } + } + +#elif MAC + +inline static void SwapFloat( float& r ) + { + DBG_ASSERT( FALSE, "SwapFloat noch nicht implementiert!\n" ); + } + +inline static void SwapDouble( double& r ) + { +#ifdef DBG_UTIL + if( sizeof(double) != 8 ) + DBG_ASSERT( FALSE, "Can only swap 8-Byte-doubles\n" ); +#endif + + UINT32* c = (UINT32*)(void*)&r; + UINT32 nHelp; + // zwei 32-Bit-Werte in situ vertauschen + // und die beiden 32-Bit-Werte selbst in situ drehen + nHelp = SWAPLONG(c[0]); + c[0] = SWAPLONG(c[1]); + c[1] = nHelp; + } +#endif // #ifdef UNX / elif MAC + +//SDO + +#define READNUMBER_WITHOUT_SWAP(datatype,value) \ +{\ +int tmp = eIOMode; \ +if( (tmp == STREAM_IO_READ) && sizeof(datatype)<=nBufFree) \ +{\ + for (int i = 0; i < sizeof(datatype); i++)\ + ((char *)&r)[i] = pBufPos[i];\ + nBufActualPos += sizeof(datatype);\ + pBufPos += sizeof(datatype);\ + nBufFree -= sizeof(datatype);\ +}\ +else\ + Read( (char*)&value, sizeof(datatype) );\ +} + +#define WRITENUMBER_WITHOUT_SWAP(datatype,value) \ +{\ +int tmp = eIOMode; \ +if( (tmp==STREAM_IO_WRITE) && sizeof(datatype) <= nBufFree)\ +{\ + for (int i = 0; i < sizeof(datatype); i++)\ + pBufPos[i] = ((char *)&value)[i];\ + nBufFree -= sizeof(datatype);\ + nBufActualPos += sizeof(datatype);\ + if( nBufActualPos > nBufActualLen )\ + nBufActualLen = nBufActualPos;\ + pBufPos += sizeof(datatype);\ + bIsDirty = TRUE;\ +}\ +else\ + Write( (char*)&value, sizeof(datatype) );\ +} + +//============================================================================ +// +// class SvLockBytes +// +//============================================================================ + +void SvLockBytes::close() +{ + if (m_bOwner) + delete m_pStream; + m_pStream = 0; +} + +//============================================================================ +TYPEINIT0(SvLockBytes); + +//============================================================================ +// virtual +ErrCode SvLockBytes::ReadAt(ULONG nPos, void * pBuffer, ULONG nCount, + ULONG * pRead) const +{ + if (!m_pStream) + { + DBG_ERROR("SvLockBytes::ReadAt(): Bad stream"); + return ERRCODE_NONE; + } + + m_pStream->Seek(nPos); + ULONG nTheRead = m_pStream->Read(pBuffer, nCount); + if (pRead) + *pRead = nTheRead; + return m_pStream->GetErrorCode(); +} + +//============================================================================ +// virtual +ErrCode SvLockBytes::WriteAt(ULONG nPos, const void * pBuffer, ULONG nCount, + ULONG * pWritten) +{ + if (!m_pStream) + { + DBG_ERROR("SvLockBytes::WriteAt(): Bad stream"); + return ERRCODE_NONE; + } + + m_pStream->Seek(nPos); + ULONG nTheWritten = m_pStream->Write(pBuffer, nCount); + if (pWritten) + *pWritten = nTheWritten; + return m_pStream->GetErrorCode(); +} + +//============================================================================ +// virtual +ErrCode SvLockBytes::Flush() const +{ + if (!m_pStream) + { + DBG_ERROR("SvLockBytes::Flush(): Bad stream"); + return ERRCODE_NONE; + } + + m_pStream->Flush(); + return m_pStream->GetErrorCode(); +} + +//============================================================================ +// virtual +ErrCode SvLockBytes::SetSize(ULONG nSize) +{ + if (!m_pStream) + { + DBG_ERROR("SvLockBytes::SetSize(): Bad stream"); + return ERRCODE_NONE; + } + + m_pStream->SetStreamSize(nSize); + return m_pStream->GetErrorCode(); +} + +//============================================================================ +ErrCode SvLockBytes::LockRegion(ULONG, ULONG, LockType) +{ + DBG_ERROR("SvLockBytes::LockRegion(): Not implemented"); + return ERRCODE_NONE; +} + +//============================================================================ + +ErrCode SvLockBytes::UnlockRegion(ULONG, ULONG, LockType) +{ + DBG_ERROR("SvLockBytes::UnlockRegion(): Not implemented"); + return ERRCODE_NONE; +} + +//============================================================================ +ErrCode SvLockBytes::Stat(SvLockBytesStat * pStat, SvLockBytesStatFlag) const +{ + if (!m_pStream) + { + DBG_ERROR("SvLockBytes::Stat(): Bad stream"); + return ERRCODE_NONE; + } + + if (pStat) + { + ULONG nPos = m_pStream->Tell(); + pStat->nSize = m_pStream->Seek(STREAM_SEEK_TO_END); + m_pStream->Seek(nPos); + } + return ERRCODE_NONE; +} + +//============================================================================ +// +// class SvOpenLockBytes +// +//============================================================================ + +TYPEINIT1(SvOpenLockBytes, SvLockBytes); + +//============================================================================ +// +// class SvAsyncLockBytes +// +//============================================================================ + +TYPEINIT1(SvAsyncLockBytes, SvOpenLockBytes); + +//============================================================================ +// virtual +ErrCode SvAsyncLockBytes::ReadAt(ULONG nPos, void * pBuffer, ULONG nCount, + ULONG * pRead) const +{ + if (m_bTerminated) + return SvOpenLockBytes::ReadAt(nPos, pBuffer, nCount, pRead); + else + { + ULONG nTheCount = min(nPos < m_nSize ? m_nSize - nPos : 0, nCount); + ErrCode nError = SvOpenLockBytes::ReadAt(nPos, pBuffer, nTheCount, + pRead); + return !nCount || nTheCount == nCount || nError ? nError : + ERRCODE_IO_PENDING; + } +} + +//============================================================================ +// virtual +ErrCode SvAsyncLockBytes::WriteAt(ULONG nPos, const void * pBuffer, + ULONG nCount, ULONG * pWritten) +{ + if (m_bTerminated) + return SvOpenLockBytes::WriteAt(nPos, pBuffer, nCount, pWritten); + else + { + ULONG nTheCount = min(nPos < m_nSize ? m_nSize - nPos : 0, nCount); + ErrCode nError = SvOpenLockBytes::WriteAt(nPos, pBuffer, nTheCount, + pWritten); + return !nCount || nTheCount == nCount || nError ? nError : + ERRCODE_IO_PENDING; + } +} + +//============================================================================ +// virtual +ErrCode SvAsyncLockBytes::FillAppend(const void * pBuffer, ULONG nCount, + ULONG * pWritten) +{ + ULONG nTheWritten; + ErrCode nError = SvOpenLockBytes::WriteAt(m_nSize, pBuffer, nCount, + &nTheWritten); + if (!nError) + m_nSize += nTheWritten; + if (pWritten) + *pWritten = nTheWritten; + return nError; +} + +//============================================================================ +// virtual +ULONG SvAsyncLockBytes::Seek(ULONG nPos) +{ + if (nPos != STREAM_SEEK_TO_END) + m_nSize = nPos; + return m_nSize; +} + +//============================================================================ +// +// class SvStream +// +//============================================================================ + +ULONG SvStream::GetData( void* pData, ULONG nSize ) +{ + if( !GetError() ) + { + DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); + ULONG nRet; + nError = xLockBytes->ReadAt( nActPos, pData, nSize, &nRet ); + nActPos += nRet; + return nRet; + } + else return 0; +} + +ErrCode SvStream::SetLockBytes( SvLockBytesRef& rLB ) +{ + xLockBytes = rLB; + RefreshBuffer(); + return ERRCODE_NONE; +} + +//======================================================================== + +ULONG SvStream::PutData( const void* pData, ULONG nSize ) +{ + if( !GetError() ) + { + DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); + ULONG nRet; + nError = xLockBytes->WriteAt( nActPos, pData, nSize, &nRet ); + nActPos += nRet; + return nRet; + } + else return 0; +} + +//======================================================================== + +ULONG SvStream::SeekPos( ULONG nPos ) +{ + if( !GetError() && nPos == STREAM_SEEK_TO_END ) + { + DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); + SvLockBytesStat aStat; + xLockBytes->Stat( &aStat, SVSTATFLAG_DEFAULT ); + nActPos = aStat.nSize; + } + else + nActPos = nPos; + return nActPos; +} + +//======================================================================== + +void SvStream::FlushData() +{ + if( !GetError() ) + { + DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); + nError = xLockBytes->Flush(); + } +} + +//======================================================================== + +void SvStream::SetSize( ULONG nSize ) +{ + DBG_ASSERT( xLockBytes.Is(), "pure virtual function" ); + nError = xLockBytes->SetSize( nSize ); +} + +void SvStream::ImpInit() +{ + nActPos = 0; + nCompressMode = COMPRESSMODE_NONE; + eStreamCharSet = osl_getThreadTextEncoding(); +// eTargetCharSet = osl_getThreadTextEncoding(); + nCryptMask = 0; + bIsEof = FALSE; +#if defined( MAC ) + eLineDelimiter = LINEEND_CR; // MAC-Format +#elif defined( UNX ) + eLineDelimiter = LINEEND_LF; // UNIX-Format +#else + eLineDelimiter = LINEEND_CRLF; // DOS-Format +#endif + + SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN ); + + nBufFilePos = 0; + nBufActualPos = 0; + bIsDirty = FALSE; + bIsConsistent = TRUE; + bIsWritable = TRUE; + + pRWBuf = 0; + pBufPos = 0; + nBufSize = 0; + nBufActualLen = 0; + eIOMode = STREAM_IO_DONTKNOW; + nBufFree = 0; + + nRadix = 10; + nPrecision = 0; // all significant digits + nWidth = 0; // default width + cFiller = ' '; + nJustification = JUSTIFY_RIGHT; + eStreamMode = 0; + CreateFormatString(); + + nVersion = 0; + + ClearError(); +} + +/************************************************************************* +|* +|* Stream::Stream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvStream::SvStream( SvLockBytes* pLockBytesP ) +{ + DBG_CTOR( Stream, NULL ); + + ImpInit(); + xLockBytes = pLockBytesP; + const SvStream* pStrm; + if( pLockBytesP && (pStrm = pLockBytesP->GetStream() ) ) + SetError( pStrm->GetErrorCode() ); + SetBufferSize( 256 ); +} + +SvStream::SvStream() +{ + DBG_CTOR( Stream, NULL ); + + ImpInit(); +} + +/************************************************************************* +|* +|* Stream::~Stream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvStream::~SvStream() +{ + DBG_DTOR( Stream, NULL ); + + if ( xLockBytes.Is() ) + Flush(); + + if( pRWBuf ) + delete pRWBuf; +} + +/************************************************************************* +|* +|* Stream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +USHORT SvStream::IsA() const +{ + return (USHORT)ID_STREAM; +} + +/************************************************************************* +|* +|* Stream::ClearError() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::ClearError() +{ + bIsEof = FALSE; + nError = SVSTREAM_OK; +} + +/************************************************************************* +|* +|* Stream::SetError() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::SetError( ULONG nErrorCode ) +{ + if ( nError == SVSTREAM_OK ) + nError = nErrorCode; +} + + +/************************************************************************* +|* +|* Stream::SetNumberFormatInt() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::SetNumberFormatInt( USHORT nNewFormat ) +{ + nNumberFormatInt = nNewFormat; + bSwap = FALSE; +#ifdef __BIGENDIAN + if( nNumberFormatInt == NUMBERFORMAT_INT_LITTLEENDIAN ) + bSwap = TRUE; +#else + if( nNumberFormatInt == NUMBERFORMAT_INT_BIGENDIAN ) + bSwap = TRUE; +#endif +} + +/************************************************************************* +|* +|* Stream::SetBufferSize() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::SetBufferSize( USHORT nBufferSize ) +{ + ULONG nActualFilePos = Tell(); + BOOL bDontSeek = (BOOL)(pRWBuf == 0); + + if( bIsDirty && bIsConsistent && bIsWritable ) // wg. Windows NT: Access denied + Flush(); + + if( nBufSize ) + { + delete pRWBuf; + nBufFilePos += nBufActualPos; + } + + pRWBuf = 0; + nBufActualLen = 0; + nBufActualPos = 0; + nBufSize = nBufferSize; + if( nBufSize ) + pRWBuf = new BYTE[ nBufSize ]; + bIsConsistent = TRUE; + pBufPos = pRWBuf; + eIOMode = STREAM_IO_DONTKNOW; + if( !bDontSeek ) + SeekPos( nActualFilePos ); +} + +/************************************************************************* +|* +|* Stream::ClearBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::ClearBuffer() +{ + nBufActualLen = 0; + nBufActualPos = 0; + nBufFilePos = 0; + pBufPos = pRWBuf; + bIsDirty = FALSE; + bIsConsistent = TRUE; + eIOMode = STREAM_IO_DONTKNOW; + + bIsEof = FALSE; +} + +/************************************************************************* +|* +|* Stream::ResetError() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::ResetError() +{ + ClearError(); +} + +/************************************************************************* +|* +|* Stream::ReadLine() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +BOOL SvStream::ReadByteStringLine( String& rStr, rtl_TextEncoding eSrcCharSet ) +{ + BOOL bRet; + ByteString aStr; + + bRet = ReadLine(aStr); + rStr = UniString( aStr, eSrcCharSet ); + return bRet; +} + +BOOL SvStream::ReadLine( ByteString& rStr ) +{ + sal_Char buf[256+1]; + BOOL bEnd = FALSE; + ULONG nOldFilePos = Tell(); + sal_Char c = 0; + + rStr.Erase(); + while( !bEnd && !GetError() ) // !!! nicht auf EOF testen, + // !!! weil wir blockweise + // !!! lesen + { + USHORT nLen = (USHORT)Read( buf, sizeof(buf)-1 ); + if ( !nLen ) + { + if ( rStr.Len() == 0 ) + { + // der allererste Blockread hat fehlgeschlagen -> Abflug + bIsEof = TRUE; + return FALSE; + } + else + break; + } + + for( USHORT n = 0; n < nLen ; n++ ) + { + c = buf[n]; + if ( c != '\n' && c != '\r' ) + rStr += c; + else + { + bEnd = TRUE; + break; + } + } + } + + if ( !bEnd && !GetError() && rStr.Len() ) + bEnd = TRUE; + + nOldFilePos += rStr.Len(); + if( Tell() > nOldFilePos ) + nOldFilePos++; + Seek( nOldFilePos ); // seeken wg. obigem BlockRead! + + if ( bEnd && (c=='\r' || c=='\n') ) // Sonderbehandlung DOS-Dateien + { + char cTemp; + Read((char*)&cTemp , sizeof(cTemp) ); + if( cTemp == c || (cTemp != '\n' && cTemp != '\r') ) + Seek( nOldFilePos ); + } + + if ( bEnd ) + bIsEof = FALSE; + return bEnd; +} + +/************************************************************************* +|* +|* Stream::WriteLine() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +BOOL SvStream::WriteByteStringLine( const String& rStr, rtl_TextEncoding eDestCharSet ) +{ + return WriteLine( ByteString( rStr, eDestCharSet ) ); +} + +BOOL SvStream::WriteLine( const ByteString& rStr ) +{ + Write( rStr.GetBuffer(), rStr.Len() ); + endl(*this); + return nError == SVSTREAM_OK; +} + +/************************************************************************* +|* +|* Stream::WriteLines() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 17.07.95 +|* Letzte Aenderung OV 17.07.95 +|* +*************************************************************************/ + +BOOL SvStream::WriteByteStringLines( const String& rStr, rtl_TextEncoding eDestCharSet ) +{ + return WriteLines( ByteString( rStr, eDestCharSet ) ); +} + +BOOL SvStream::WriteLines( const ByteString& rStr ) +{ + ByteString aStr( rStr ); + aStr.ConvertLineEnd( eLineDelimiter ); + Write( aStr.GetBuffer(), aStr.Len() ); + endl( *this ); + return (BOOL)(nError == SVSTREAM_OK); +} + +/************************************************************************* +|* +|* Stream::SeekRel() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +ULONG SvStream::SeekRel( long nPos ) +{ + ULONG nActualPos = Tell(); + nActualPos += nPos; + pBufPos = pRWBuf + nActualPos; + return Seek( nActualPos ); +} + +/************************************************************************* +|* +|* Stream::operator>>() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvStream& SvStream::operator >> ( USHORT& r ) +{ + READNUMBER_WITHOUT_SWAP(USHORT,r) + if( bSwap ) + SwapUShort(r); + return *this; +} + +SvStream& SvStream::operator>> ( ULONG& r) +{ +#if(__SIZEOFLONG != 4) + unsigned int tmp = r; + READNUMBER_WITHOUT_SWAP(ULONG,tmp) + r = tmp; + if( bSwap ) + SwapULong(r); +#else + READNUMBER_WITHOUT_SWAP(ULONG,r) + if( bSwap ) + SwapULong(r); +#endif + return *this; +} + +SvStream& SvStream::operator >> ( long& r ) +{ +#if(__SIZEOFLONG != 4) + unsigned int tmp = r; + READNUMBER_WITHOUT_SWAP(long,tmp) + r = tmp; + if( bSwap ) + SwapLong(r); +#else + READNUMBER_WITHOUT_SWAP(long,r) + if( bSwap ) + SwapLong(r); +#endif + return *this; +} + +SvStream& SvStream::operator >> ( short& r) +{ + READNUMBER_WITHOUT_SWAP(short,r) + if( bSwap ) + SwapShort(r); + return *this; +} + +SvStream& SvStream::operator >> ( int& r) +{ + READNUMBER_WITHOUT_SWAP(int,r) + if( bSwap ) + { +#if(__SIZEOFINT == 2) + SwapInt(r); +#else + SwapLongInt(r); +#endif + } + return *this; +} + +SvStream& SvStream::operator>>( unsigned int& r) +{ + READNUMBER_WITHOUT_SWAP(unsigned int,r) + if( bSwap ) + { +#if(__SIZEOFINT == 2) + SwapUInt(r); +#else + SwapLongUInt(r); +#endif + } + return *this; +} + +SvStream& SvStream::operator>>( signed char& r) +{ + if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && + sizeof(signed char) <= nBufFree ) + { + r = *pBufPos; + nBufActualPos += sizeof(signed char); + pBufPos += sizeof(signed char); + nBufFree -= sizeof(signed char); + } + else + Read( (char*)&r, sizeof(signed char) ); + return *this; +} + +// Sonderbehandlung fuer Chars wegen PutBack + +SvStream& SvStream::operator>>( char& r) +{ + if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && + sizeof(char) <= nBufFree ) + { + r = *pBufPos; + nBufActualPos += sizeof(char); + pBufPos += sizeof(char); + nBufFree -= sizeof(char); + } + else + Read( (char*)&r, sizeof(char) ); + return *this; +} + +SvStream& SvStream::operator>>( unsigned char& r) +{ + if( (eIOMode == STREAM_IO_READ || !bIsConsistent) && + sizeof(char) <= nBufFree ) + { + r = *pBufPos; + nBufActualPos += sizeof(char); + pBufPos += sizeof(char); + nBufFree -= sizeof(char); + } + else + Read( (char*)&r, sizeof(char) ); + return *this; +} + +SvStream& SvStream::operator>>( float& r) +{ + // Read( (char*)&r, sizeof(float) ); + READNUMBER_WITHOUT_SWAP(float,r) +#ifdef UNX + if( bSwap ) + SwapFloat(r); +#endif + return *this; +} + +SvStream& SvStream::operator>>( double& r) +{ + // Read( (char*)&r, sizeof(double) ); + READNUMBER_WITHOUT_SWAP(double,r) +#if defined( UNX ) || defined ( MAC ) + if( bSwap ) + SwapDouble(r); +#endif + return *this; +} + +SvStream& SvStream::operator>> ( SvStream& rStream ) +{ + const ULONG cBufLen = 0x8000; + char* pBuf = new char[ cBufLen ]; + + ULONG nCount; + do { + nCount = Read( pBuf, cBufLen ); + rStream.Write( pBuf, nCount ); + } while( nCount == cBufLen ); + + delete pBuf; + return *this; +} + +/************************************************************************* +|* +|* Stream::operator<<() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvStream& SvStream::operator<< ( USHORT v ) +{ + if( bSwap ) + SwapUShort(v); + WRITENUMBER_WITHOUT_SWAP(USHORT,v) + return *this; +} + +SvStream& SvStream::operator<< ( ULONG v) +{ +#if(__SIZEOFLONG != 4) + unsigned int tmp = v; + if( bSwap ) + SwapUInt(tmp); + WRITENUMBER_WITHOUT_SWAP(unsigned int,tmp) +#else + if( bSwap ) + SwapULong(v); + WRITENUMBER_WITHOUT_SWAP(ULONG,v) +#endif + return *this; +} + +SvStream& SvStream::operator<< ( long v ) +{ +#if(__SIZEOFLONG != 4) + int tmp = v; + if( bSwap ) + SwapInt(tmp); + WRITENUMBER_WITHOUT_SWAP(int,tmp) +#else + if( bSwap ) + SwapLong(v); + WRITENUMBER_WITHOUT_SWAP(long,v) +#endif + return *this; +} + +SvStream& SvStream::operator<< ( short v) +{ + if( bSwap ) + SwapShort(v); + WRITENUMBER_WITHOUT_SWAP(short,v) + return *this; +} + +SvStream& SvStream::operator<<( int v) +{ + if( bSwap ) + { +#if( __SIZEOFINT == 2 ) + SwapInt( v ); +#else + SwapLongInt( v ); +#endif + } + WRITENUMBER_WITHOUT_SWAP(int,v) + return *this; +} + +SvStream& SvStream::operator<< ( signed char v) +{ + //SDO + int tmp = eIOMode; + if(tmp == STREAM_IO_WRITE && sizeof(signed char) <= nBufFree ) + { + *pBufPos = v; + pBufPos++; // sizeof(char); + nBufActualPos++; + if( nBufActualPos > nBufActualLen ) // Append ? + nBufActualLen = nBufActualPos; + nBufFree--; // = sizeof(char); + bIsDirty = TRUE; + } + else + Write( (char*)&v, sizeof(signed char) ); + return *this; +} + + +SvStream& SvStream::operator<< ( unsigned int v) +{ + if( bSwap ) + { +#if( __SIZEOFINT == 2 ) + SwapUInt( v ); +#else + SwapLongUInt( v ); +#endif + } + WRITENUMBER_WITHOUT_SWAP(int,v) + return *this; +} + +// Sonderbehandlung fuer chars wegen PutBack + +SvStream& SvStream::operator<< ( char v) +{ + //SDO + int tmp = eIOMode; + if(tmp == STREAM_IO_WRITE && sizeof(char) <= nBufFree ) + { + *pBufPos = v; + pBufPos++; // sizeof(char); + nBufActualPos++; + if( nBufActualPos > nBufActualLen ) // Append ? + nBufActualLen = nBufActualPos; + nBufFree--; // = sizeof(char); + bIsDirty = TRUE; + } + else + Write( (char*)&v, sizeof(char) ); + return *this; +} + +SvStream& SvStream::operator<< ( unsigned char v) +{ +//SDO + int tmp = eIOMode; + if(tmp == STREAM_IO_WRITE && sizeof(char) <= nBufFree ) + { + *(unsigned char*)pBufPos = v; + pBufPos++; // = sizeof(char); + nBufActualPos++; // = sizeof(char); + if( nBufActualPos > nBufActualLen ) // Append ? + nBufActualLen = nBufActualPos; + nBufFree--; + bIsDirty = TRUE; + } + else + Write( (char*)&v, sizeof(char) ); + return *this; +} + +SvStream& SvStream::operator<< ( float v) +{ +#ifdef UNX + if( bSwap ) + SwapFloat(v); +#endif + WRITENUMBER_WITHOUT_SWAP(float,v) + return *this; +} + +SvStream& SvStream::operator<< ( const double& r) +{ +// Write( (char*)&r, sizeof( double ) ); +#if defined( UNX ) || defined ( MAC ) + if( bSwap ) + { + double nHelp = r; + SwapDouble(nHelp); + WRITENUMBER_WITHOUT_SWAP(double,nHelp) + return *this; + } + else +#endif + WRITENUMBER_WITHOUT_SWAP(double,r) + + return *this; +} + +SvStream& SvStream::operator<< ( const char* pBuf ) +{ + Write( pBuf, strlen( pBuf ) ); + return *this; +} + +SvStream& SvStream::operator<< ( const unsigned char* pBuf ) +{ + Write( (char*)pBuf, strlen( (char*)pBuf ) ); + return *this; +} + +SvStream& SvStream::operator<< ( SvStream& rStream) +{ + const ULONG cBufLen = 0x8000; + char* pBuf = new char[ cBufLen ]; + ULONG nCount; + do { + nCount = rStream.Read( pBuf, cBufLen ); + Write( pBuf, nCount ); + } while( nCount == cBufLen ); + + delete pBuf; + return *this; +} + +// ----------------------------------------------------------------------- + +SvStream& SvStream::ReadByteString( UniString& rStr, rtl_TextEncoding eSrcCharSet ) +{ + // read UTF-16 string directly from stream ? + if (eSrcCharSet == RTL_TEXTENCODING_UNICODE) + { + sal_uInt32 nLen; + operator>> (nLen); + if (nLen) + { + sal_Unicode *pStr = rStr.AllocBuffer(nLen); + Read( pStr, nLen << 1 ); + + if (bSwap) + for (sal_Unicode *pEnd = pStr + nLen; pStr < pEnd; pStr++) + SwapUShort(*pStr); + } + else + rStr.Erase(); + + return *this; + } + + ByteString aStr; + ReadByteString( aStr ); + rStr = UniString( aStr, eSrcCharSet ); + return *this; +} + +// ----------------------------------------------------------------------- + +SvStream& SvStream::ReadByteString( ByteString& rStr ) +{ + USHORT nLen = 0; + operator>>( nLen ); + if( nLen ) + { + char* pTmp = rStr.AllocBuffer( nLen ); + nLen = (USHORT)Read( pTmp, nLen ); + } + else + rStr.Erase(); + return *this; +} + +// ----------------------------------------------------------------------- + +SvStream& SvStream::WriteByteString( const UniString& rStr, rtl_TextEncoding eDestCharSet ) +{ + // write UTF-16 string directly into stream ? + if (eDestCharSet == RTL_TEXTENCODING_UNICODE) + { + sal_uInt32 nLen = rStr.Len(); + operator<< (nLen); + if (nLen) + { + if (bSwap) + { + const sal_Unicode *pStr = rStr.GetBuffer(); + const sal_Unicode *pEnd = pStr + nLen; + + for (; pStr < pEnd; pStr++) + { + sal_Unicode c = *pStr; + SwapUShort(c); + WRITENUMBER_WITHOUT_SWAP(USHORT,c) + } + } + else + Write( rStr.GetBuffer(), nLen << 1 ); + } + + return *this; + } + + return WriteByteString(ByteString( rStr, eDestCharSet )); +} + +// ----------------------------------------------------------------------- + +SvStream& SvStream::WriteByteString( const ByteString& rStr) +{ + USHORT nLen = rStr.Len(); + operator<< ( nLen ); + if( nLen != 0 ) + Write( rStr.GetBuffer(), nLen ); + return *this; +} + +/************************************************************************* +|* +|* Stream::Read() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +ULONG SvStream::Read( void* pData, ULONG nCount ) +{ + ULONG nSaveCount = nCount; + if( !bIsConsistent ) + RefreshBuffer(); + + if( !pRWBuf ) + { + nCount = GetData( (char*)pData,nCount); + if( nCryptMask ) + EncryptBuffer(pData, nCount); + nBufFilePos += nCount; + } + else + { + // ist Block komplett im Puffer + eIOMode = STREAM_IO_READ; + if( nCount <= (ULONG)(nBufActualLen - nBufActualPos ) ) + { + // Ja! +#ifdef WIN + hmemcpy( pData, pBufPos, nCount ); +#else + memcpy(pData, pBufPos, (size_t) nCount); +#endif + nBufActualPos += (USHORT)nCount; + pBufPos += nCount; + nBufFree -= (USHORT)nCount; + } + else + { + if( bIsDirty ) // Flushen ? + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer(pRWBuf, nBufActualLen); + else + PutData( pRWBuf, nBufActualLen ); + bIsDirty = FALSE; + } + + // passt der Datenblock in den Puffer ? + if( nCount > nBufSize ) + { + // Nein! Deshalb ohne Umweg ueber den Puffer direkt + // in den Zielbereich einlesen + + eIOMode = STREAM_IO_DONTKNOW; + + SeekPos( nBufFilePos + nBufActualPos ); + nBufActualLen = 0; + pBufPos = pRWBuf; + nCount = GetData( (char*)pData, nCount ); + if( nCryptMask ) + EncryptBuffer(pData, nCount); + nBufFilePos += nCount; + nBufFilePos += nBufActualPos; + nBufActualPos = 0; + } + else + { + // Der Datenblock passt komplett in den Puffer. Deshalb + // Puffer fuellen und dann die angeforderten Daten in den + // Zielbereich kopieren. + + nBufFilePos += nBufActualPos; + SeekPos( nBufFilePos ); + + // TODO: Typecast vor GetData, USHORT nCountTmp + ULONG nCountTmp = GetData( pRWBuf, nBufSize ); + if( nCryptMask ) + EncryptBuffer(pRWBuf, nCountTmp); + nBufActualLen = (USHORT)nCountTmp; + if( nCount > nCountTmp ) + { + nCount = nCountTmp; // zurueckstutzen, Eof siehe unten + } +#ifdef WIN + hmemcpy( pData, pRWBuf, nCount ); +#else + memcpy( pData, pRWBuf, (size_t)nCount ); +#endif + nBufActualPos = (USHORT)nCount; + pBufPos = pRWBuf + nCount; + } + } + } + bIsEof = FALSE; + nBufFree = nBufActualLen - nBufActualPos; + if( nCount != nSaveCount && nError != ERRCODE_IO_PENDING ) + bIsEof = TRUE; + if( nCount == nSaveCount && nError == ERRCODE_IO_PENDING ) + nError = ERRCODE_NONE; + return nCount; +} + +/************************************************************************* +|* +|* Stream::Write() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +ULONG SvStream::Write( const void* pData, ULONG nCount ) +{ + if( !nCount ) + return 0; + if( !bIsWritable ) + { + SetError( ERRCODE_IO_CANTWRITE ); + return 0; + } + if( !bIsConsistent ) + RefreshBuffer(); // Aenderungen des Puffers durch PutBack loeschen + + if( !pRWBuf ) + { + if( nCryptMask ) + nCount = CryptAndWriteBuffer( pData, nCount ); + else + nCount = PutData( (char*)pData, nCount ); + nBufFilePos += nCount; + return nCount; + } + + eIOMode = STREAM_IO_WRITE; + if( nCount <= (ULONG)(nBufSize - nBufActualPos) ) + { +#ifdef WIN + hmemcpy( pBufPos, pData, nCount ); +#else + memcpy( pBufPos, pData, (size_t)nCount ); +#endif + nBufActualPos += (USHORT)nCount; + // wurde der Puffer erweitert ? + if( nBufActualPos > nBufActualLen ) + nBufActualLen = nBufActualPos; + + pBufPos += nCount; + bIsDirty = TRUE; + } + else + { + // Flushen ? + if( bIsDirty ) + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer( pRWBuf, (ULONG)nBufActualLen ); + else + PutData( pRWBuf, nBufActualLen ); + bIsDirty = FALSE; + } + + // passt der Block in den Puffer ? + if( nCount > nBufSize ) + { + eIOMode = STREAM_IO_DONTKNOW; + nBufFilePos += nBufActualPos; + nBufActualLen = 0; + nBufActualPos = 0; + pBufPos = pRWBuf; + SeekPos( nBufFilePos ); + if( nCryptMask ) + nCount = CryptAndWriteBuffer( pData, nCount ); + else + nCount = PutData( (char*)pData, nCount ); + nBufFilePos += nCount; + } + else + { + // Block in Puffer stellen +#ifdef WIN + hmemcpy( pRWBuf, pData, nCount ); +#else + memcpy( pRWBuf, pData, (size_t)nCount ); +#endif + // Reihenfolge! + nBufFilePos += nBufActualPos; + nBufActualPos = (USHORT)nCount; + pBufPos = pRWBuf + nCount; + nBufActualLen = (USHORT)nCount; + bIsDirty = TRUE; + } + } + nBufFree = nBufSize - nBufActualPos; + return nCount; +} + + +/************************************************************************* +|* +|* Stream::Seek() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +ULONG SvStream::Seek( ULONG nFilePos ) +{ + eIOMode = STREAM_IO_DONTKNOW; + + bIsEof = FALSE; + if( !pRWBuf ) + { + nBufFilePos = SeekPos( nFilePos ); + DBG_ASSERT(Tell()==nBufFilePos,"Out Of Sync!") + return nBufFilePos; + } + + // Ist Position im Puffer ? + if( nFilePos >= nBufFilePos && nFilePos <= (nBufFilePos + nBufActualLen)) + { + nBufActualPos = (USHORT)(nFilePos - nBufFilePos); + pBufPos = pRWBuf + nBufActualPos; + // nBufFree korrigieren, damit wir nicht von einem + // PutBack (ignoriert den StreamMode) getoetet werden + nBufFree = nBufActualLen - nBufActualPos; + } + else + { + if( bIsDirty && bIsConsistent) + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer( pRWBuf, nBufActualLen ); + else + PutData( pRWBuf, nBufActualLen ); + bIsDirty = FALSE; + } + nBufActualLen = 0; + nBufActualPos = 0; + pBufPos = pRWBuf; + nBufFilePos = SeekPos( nFilePos ); + } +#ifdef OV_DEBUG + { + ULONG nDebugTemp = nBufFilePos + nBufActualPos; + DBG_ASSERT(Tell()==nDebugTemp,"Sync?") + } +#endif + return nBufFilePos + nBufActualPos; +} + +/************************************************************************* +|* +|* Stream::Flush() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::Flush() +{ + if( bIsDirty && bIsConsistent ) + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer( pRWBuf, (ULONG)nBufActualLen ); + else + if( PutData( pRWBuf, nBufActualLen ) != nBufActualLen ) + SetError( SVSTREAM_WRITE_ERROR ); + bIsDirty = FALSE; + } + if( bIsWritable ) + FlushData(); +} + + +/************************************************************************* +|* +|* Stream::PutBack() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 01.08.94 +|* Letzte Aenderung OV 01.08.94 +|* +*************************************************************************/ + +/* + 4 Faelle : + + 1. Datenzeiger steht mitten im Puffer (nBufActualPos >= 1) + 2. Datenzeiger auf Position 0, Puffer ist voll + 3. Datenzeiger auf Position 0, Puffer ist teilweise gefuellt + 4. Datenzeiger auf Position 0, Puffer ist leer -> Fehler! +*/ + +SvStream& SvStream::PutBack( char aCh ) +{ + // wenn kein Buffer oder Zurueckscrollen nicht moeglich -> Fehler + if( !pRWBuf || !nBufActualLen || ( !nBufActualPos && !nBufFilePos ) ) + { + // 4. Fall + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + + // Flush() (Phys. Flushen aber nicht notwendig, deshalb selbst schreiben) + if( bIsConsistent && bIsDirty ) + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer( pRWBuf, nBufActualLen ); + else + PutData( pRWBuf, nBufActualLen ); + bIsDirty = FALSE; + } + bIsConsistent = FALSE; // Puffer enthaelt jetzt TRASH + if( nBufActualPos ) + { + // 1. Fall + nBufActualPos--; + pBufPos--; + *pBufPos = aCh; + nBufFree++; + } + else // Puffer muss verschoben werden + { + // Ist Puffer am Anschlag ? + if( nBufSize == nBufActualLen ) + { + // 2. Fall + memmove( pRWBuf+1, pRWBuf, nBufSize-1 ); + // nBufFree behaelt den Wert! + } + else + { + // 3. Fall -> Puffer vergroessern + memmove( pRWBuf+1, pRWBuf, (USHORT)nBufActualLen ); + nBufActualLen++; + nBufFree++; + } + nBufFilePos--; + *pRWBuf = aCh; + } + eIOMode = STREAM_IO_DONTKNOW; + bIsEof = FALSE; + return *this; +} + +/************************************************************************* +|* +|* Stream::EatWhite() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 01.08.94 +|* Letzte Aenderung OV 01.08.94 +|* +*************************************************************************/ + +void SvStream::EatWhite() +{ + char aCh; + Read(&aCh, sizeof(char) ); + while( !bIsEof && isspace((int)aCh) ) //( aCh == ' ' || aCh == '\t' ) ) + Read(&aCh, sizeof(char) ); + if( !bIsEof ) // konnte das letzte Char gelesen werden ? + SeekRel( -1L ); +} + +/************************************************************************* +|* +|* Stream::RefreshBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 01.08.94 +|* Letzte Aenderung OV 01.08.94 +|* +*************************************************************************/ + +void SvStream::RefreshBuffer() +{ + if( bIsDirty && bIsConsistent ) + { + SeekPos( nBufFilePos ); + if( nCryptMask ) + CryptAndWriteBuffer( pRWBuf, (ULONG)nBufActualLen ); + else + PutData( pRWBuf, nBufActualLen ); + bIsDirty = FALSE; + } + SeekPos( nBufFilePos ); + nBufActualLen = (USHORT)GetData( pRWBuf, nBufSize ); + if( nBufActualLen && nError == ERRCODE_IO_PENDING ) + nError = ERRCODE_NONE; + if( nCryptMask ) + EncryptBuffer(pRWBuf, (ULONG)nBufActualLen); + bIsConsistent = TRUE; + eIOMode = STREAM_IO_DONTKNOW; +} + + +/************************************************************************* +|* +|* Stream::CreateFormatString() +|* +|* Beschreibung Baut Formatstring zusammen +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::CreateFormatString() +{ + aFormatString = '%'; + nPrintfParams = SPECIAL_PARAM_NONE; + + if( nJustification ) + { + aFormatString += '-'; + } + + if( nWidth ) + { + if( cFiller != ' ' ) + aFormatString += '0'; + aFormatString += '*'; + nPrintfParams = SPECIAL_PARAM_WIDTH; + } + + if( nPrecision ) + { + aFormatString += ".*"; + if( nWidth ) + nPrintfParams = SPECIAL_PARAM_BOTH; + else + nPrintfParams = SPECIAL_PARAM_PRECISION; + } +} + +/************************************************************************* +|* +|* Stream::ReadNumber() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +#define BUFSIZE_LONG 21 // log( 2 hoch 64 ) + 1 + +SvStream& SvStream::ReadNumber( long& rLong ) +{ + EatWhite(); + if( bIsEof || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + ULONG nFPtr = Tell(); + char buf[ BUFSIZE_LONG ]; + memset( buf, 0, BUFSIZE_LONG ); + ULONG nTemp = Read( buf, BUFSIZE_LONG-1 ); + if( !nTemp || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + char *pEndPtr; + rLong = strtol( buf, &pEndPtr, (int)nRadix ); + nFPtr += ( (ULONG)pEndPtr - (ULONG)(&(buf[0])) ); + Seek( nFPtr ); + bIsEof = FALSE; + return *this; +} + +SvStream& SvStream::ReadNumber( ULONG& rULong ) +{ + EatWhite(); + if( bIsEof || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + ULONG nFPtr = Tell(); + char buf[ BUFSIZE_LONG ]; + memset( buf, 0, BUFSIZE_LONG ); + ULONG nTemp = Read( buf, BUFSIZE_LONG-1 ); + if( !nTemp || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + char *pEndPtr; + rULong = strtoul( buf, &pEndPtr, (int)nRadix ); + nFPtr += ( (ULONG)pEndPtr - (ULONG)buf ); + Seek( nFPtr ); + bIsEof = FALSE; + return *this; +} + +SvStream& SvStream::ReadNumber( double& rDouble ) +{ + EatWhite(); + if( bIsEof || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + ULONG nFPtr = Tell(); + char buf[ BUFSIZE_LONG ]; + memset( buf, 0, BUFSIZE_LONG ); + ULONG nTemp = Read( buf, BUFSIZE_LONG-1 ); + if( !nTemp || nError ) + { + SetError( SVSTREAM_GENERALERROR ); + return *this; + } + char *pEndPtr; + rDouble = strtod( buf, &pEndPtr ); + nFPtr += ( (ULONG)pEndPtr - (ULONG)buf ); + Seek( nFPtr ); + bIsEof = FALSE; + return *this; +} + + +/************************************************************************* +|* +|* Stream::WriteNumber() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvStream& SvStream::WriteNumber( long nLong ) +{ + char buffer[256+12]; + char pType[] = "ld"; // Nicht static! + if( nRadix == 16 ) + pType[1] = 'x'; + else if( nRadix == 8 ) + pType[1] = 'o'; + ByteString aFStr( aFormatString); + aFStr += pType; + int nLen; + switch ( nPrintfParams ) + { + case SPECIAL_PARAM_NONE : + nLen = sprintf( buffer, aFStr.GetBuffer(), nLong ); + break; + case SPECIAL_PARAM_WIDTH : + nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, nLong ); + break; + case SPECIAL_PARAM_PRECISION : + nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision,nLong); + break; + default: + nLen=sprintf(buffer, aFStr.GetBuffer(),nWidth,nPrecision,nLong); + } + Write( buffer, (long)nLen ); + return *this; +} + +SvStream& SvStream::WriteNumber( ULONG nULong ) +{ + char buffer[256+12]; + char pType[] = "lu"; // Nicht static! + if( nRadix == 16 ) + pType[1] = 'x'; + else if( nRadix == 8 ) + pType[1] = 'o'; + ByteString aFStr( aFormatString); + aFStr += pType; + int nLen; + switch ( nPrintfParams ) + { + case SPECIAL_PARAM_NONE : + nLen = sprintf( buffer, aFStr.GetBuffer(), nULong ); + break; + case SPECIAL_PARAM_WIDTH : + nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, nULong ); + break; + case SPECIAL_PARAM_PRECISION : + nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision,nULong); + break; + default: + nLen=sprintf(buffer,aFStr.GetBuffer(),nWidth,nPrecision,nULong); + } + Write( buffer, (long)nLen ); + return *this; +} + + +SvStream& SvStream::WriteNumber( const double& rDouble ) +{ + char buffer[256+24]; + ByteString aFStr( aFormatString); + aFStr += "lf"; + int nLen; + switch ( nPrintfParams ) + { + case SPECIAL_PARAM_NONE : + nLen = sprintf( buffer, aFStr.GetBuffer(), rDouble ); + break; + case SPECIAL_PARAM_WIDTH : + nLen = sprintf( buffer, aFStr.GetBuffer(), nWidth, rDouble ); + break; + case SPECIAL_PARAM_PRECISION : + nLen = sprintf( buffer, aFStr.GetBuffer(), nPrecision, rDouble); + break; + default: + nLen=sprintf(buffer, aFStr.GetBuffer(),nWidth,nPrecision,rDouble); + } + Write( buffer, (long)nLen ); + return *this; +} + +/************************************************************************* +|* +|* Stream::CryptAndWriteBuffer() +|* +|* Beschreibung Verschluesseln und Schreiben +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +#define CRYPT_BUFSIZE 1024 + +ULONG SvStream::CryptAndWriteBuffer( const void* pStart, ULONG nLen) +{ + unsigned char* pTemp = new unsigned char[CRYPT_BUFSIZE]; + unsigned char* pDataPtr = (unsigned char*)pStart; + ULONG nCount = 0; + ULONG nBufCount; + unsigned char nMask = nCryptMask; + do + { + if( nLen >= CRYPT_BUFSIZE ) + nBufCount = CRYPT_BUFSIZE; + else + nBufCount = nLen; + nLen -= nBufCount; + memcpy( pTemp, pDataPtr, (USHORT)nBufCount ); + // **** Verschluesseln ***** + for ( USHORT n=0; n < CRYPT_BUFSIZE; n++ ) + { + unsigned char aCh = pTemp[n]; + aCh ^= nMask; + SWAPNIBBLES(aCh) + pTemp[n] = aCh; + } + // ************************* + nCount += PutData( (char*)pTemp, nBufCount ); + pDataPtr += nBufCount; + } + while ( nLen ); + delete pTemp; + return nCount; +} + +/************************************************************************* +|* +|* Stream::EncryptBuffer() +|* +|* Beschreibung Buffer entschluesseln +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +BOOL SvStream::EncryptBuffer(void* pStart, ULONG nLen) +{ + unsigned char* pTemp = (unsigned char*)pStart; + unsigned char nMask = nCryptMask; + + for ( ULONG n=0; n < nLen; n++, pTemp++ ) + { + unsigned char aCh = *pTemp; + SWAPNIBBLES(aCh) + aCh ^= nMask; + *pTemp = aCh; + } + return TRUE; +} + +/************************************************************************* +|* +|* Stream::SetKey() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +unsigned char implGetCryptMask(const sal_Char* pStr, sal_Int32 nLen, long nVersion) +{ + unsigned char nCryptMask = 0; + + if (!nLen) + return nCryptMask; + + if( nVersion <= SOFFICE_FILEFORMAT_31 ) + { + while( nLen ) + { + nCryptMask ^= *pStr; + pStr++; + nLen--; + } + } + else // BugFix #25888# + { + for( USHORT i = 0; i < nLen; i++ ) { + nCryptMask ^= pStr[i]; + if( nCryptMask & 0x80 ) { + nCryptMask <<= 1; + nCryptMask++; + } + else + nCryptMask <<= 1; + } + } + + if( !nCryptMask ) + nCryptMask = 67; + + return nCryptMask; +} + +void SvStream::SetKey( const ByteString& rKey ) +{ + aKey = rKey; + nCryptMask = implGetCryptMask( aKey.GetBuffer(), aKey.Len(), GetVersion() ); +} + +/************************************************************************* +|* +|* Stream::SyncSvStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::SyncSvStream( ULONG nNewStreamPos ) +{ + ClearBuffer(); + SvStream::nBufFilePos = nNewStreamPos; +} + +/************************************************************************* +|* +|* Stream::SyncSysStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +void SvStream::SyncSysStream() +{ + Flush(); + SeekPos( Tell() ); +} + +/************************************************************************* +|* +|* Stream::SetStreamSize() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +BOOL SvStream::SetStreamSize( ULONG nSize ) +{ +#ifdef DBG_UTIL + ULONG nFPos = Tell(); +#endif + USHORT nBuf = nBufSize; + SetBufferSize( 0 ); + SetSize( nSize ); + SetBufferSize( nBuf ); + DBG_ASSERT(Tell()==nFPos,"SetStreamSize failed") + return (BOOL)(nError == 0); +} + +//============================================================================ + +void SvStream::AddMark( ULONG nPos ) +{ +} + +//============================================================================ + +void SvStream::RemoveMark( ULONG nPos ) +{ +} + +/************************************************************************* +|* +|* endl() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung TH 13.11.96 +|* +*************************************************************************/ + +SvStream& endl( SvStream& rStr ) +{ + LineEnd eDelim = rStr.GetLineDelimiter(); + if ( eDelim == LINEEND_CR ) + rStr << _CR; + else if( eDelim == LINEEND_LF ) + rStr << _LF; + else + rStr << _CR << _LF; + return rStr; +} + +/************************************************************************* +|* +|* SvMemoryStream::SvMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +SvMemoryStream::SvMemoryStream( void* pBuffer, ULONG nBufSize, + StreamMode eMode ) +{ + if( eMode & STREAM_WRITE ) + bIsWritable = TRUE; + else + bIsWritable = FALSE; + nEndOfData = nBufSize; + bOwnsData = FALSE; + pBuf = (BYTE *) pBuffer; + nResize = 0L; + nSize = nBufSize; + nPos = 0L; + SetBufferSize( 0 ); +} + +/************************************************************************* +|* +|* SvMemoryStream::SvMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +SvMemoryStream::SvMemoryStream( ULONG nInitSize, ULONG nResizeOffset ) +{ + bIsWritable = TRUE; + bOwnsData = TRUE; + nEndOfData = 0L; + nResize = nResizeOffset; + nPos = 0; + pBuf = 0; + if( nResize != 0 && nResize < 16 ) + nResize = 16; + if( nInitSize && !AllocateMemory( nInitSize ) ) + { + SetError( SVSTREAM_OUTOFMEMORY ); + nSize = 0; + } + else + nSize = nInitSize; + SetBufferSize( 64 ); +} + +/************************************************************************* +|* +|* SvMemoryStream::~SvMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +SvMemoryStream::~SvMemoryStream() +{ + if( pBuf ) + { + if( bOwnsData ) + FreeMemory(); + else + Flush(); + } +} + +/************************************************************************* +|* +|* SvMemoryStream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +USHORT SvMemoryStream::IsA() const +{ + return (USHORT)ID_MEMORYSTREAM; +} + +/************************************************************************* +|* +|* SvMemoryStream::SetBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +void* SvMemoryStream::SetBuffer( void* pNewBuf, ULONG nCount, + BOOL bOwnsDat, ULONG nEOF ) +{ + void* pResult; + SetBufferSize( 0 ); // Buffering in der Basisklasse initialisieren + Seek( 0 ); + if( bOwnsData ) + { + pResult = 0; + if( pNewBuf != pBuf ) + FreeMemory(); + } + else + pResult = pBuf; + + pBuf = (BYTE *) pNewBuf; + nPos = 0; + nSize = nCount; + nResize = 0; + bOwnsData = bOwnsDat; + + if( nEOF > nCount ) + nEOF = nCount; + nEndOfData = nEOF; + + ResetError(); + + DBG_ASSERT( nEndOfData<STREAM_SEEK_TO_END,"Invalid EOF"); + return pResult; +} + +/************************************************************************* +|* +|* SvMemoryStream::GetData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +ULONG SvMemoryStream::GetData( void* pData, ULONG nCount ) +{ + ULONG nMaxCount = nEndOfData-nPos; + if( nCount > nMaxCount ) + nCount = nMaxCount; +#ifdef WIN + void _huge* pTmp = (void _huge*)((char _huge*)pBuf + nPos); + hmemcpy( (void _huge*)pData, pTmp, (long)nCount); +#else + memcpy( pData, pBuf+nPos, (size_t)nCount ); +#endif + nPos += nCount; + return nCount; +} + +/************************************************************************* +|* +|* SvMemoryStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +ULONG SvMemoryStream::PutData( const void* pData, ULONG nCount ) +{ + if( GetError() ) + return 0L; + + ULONG nMaxCount = nSize-nPos; + + // auf Ueberlauf testen + if( nCount > nMaxCount ) + { + if( nResize == 0 ) + { + // soviel wie moeglich rueberschaufeln + nCount = nMaxCount; + SetError( SVSTREAM_OUTOFMEMORY ); + } + else + { + long nNewResize; + if( nSize && nSize > nResize ) + nNewResize = nSize; + else + nNewResize = nResize; + + if( (nCount-nMaxCount) < nResize ) + { + // fehlender Speicher ist kleiner als Resize-Offset, + // deshalb um Resize-Offset vergroessern + if( !ReAllocateMemory( nNewResize) ) + { + nCount = 0; + SetError( SVSTREAM_WRITE_ERROR ); + } + } + else + { + // fehlender Speicher ist groesser als Resize-Offset + // deshalb um Differenz+ResizeOffset vergroessern + if( !ReAllocateMemory( nCount-nMaxCount+nNewResize ) ) + { + nCount = 0; + SetError( SVSTREAM_WRITE_ERROR ); + } + } + } + } + DBG_ASSERT(pBuf,"Possibly Reallocate failed"); +#ifdef WIN + void _huge* pTmp = (void _huge*)((char _huge*)pBuf + nPos); + hmemcpy( pTmp, (void _huge*)pData,(long)nCount); +#else + memcpy( pBuf+nPos, pData, (size_t)nCount); +#endif + + nPos += nCount; + if( nPos > nEndOfData ) + nEndOfData = nPos; + return nCount; +} + +/************************************************************************* +|* +|* SvMemoryStream::SeekPos() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +// nEndOfData: Erste Position im Stream, die nicht gelesen werden darf +// nSize: Groesse des allozierten Speichers + +ULONG SvMemoryStream::SeekPos( ULONG nNewPos ) +{ + if( nNewPos < nEndOfData ) + nPos = nNewPos; + else if( nNewPos == STREAM_SEEK_TO_END ) + nPos = nEndOfData; + else + { + if( nNewPos >= nSize ) // muss Buffer vergroessert werden ? + { + if( nResize ) // ist vergroeseern erlaubt ? + { + long nDiff = (long)(nNewPos - nSize + 1); + nDiff += (long)nResize; + ReAllocateMemory( nDiff ); + nPos = nNewPos; + nEndOfData = nNewPos; + } + else // vergroessern ist nicht erlaubt -> ans Ende setzen + { + // SetError( SVSTREAM_OUTOFMEMORY ); + nPos = nEndOfData; + } + } + else // gueltigen Bereich innerhalb des Buffers vergroessern + { + nPos = nNewPos; + nEndOfData = nNewPos; + } + } + return nPos; +} + +/************************************************************************* +|* +|* SvMemoryStream::FlushData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +void SvMemoryStream::FlushData() +{ +} + +/************************************************************************* +|* +|* SvMemoryStream::ResetError() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +void SvMemoryStream::ResetError() +{ + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvMemoryStream::AllocateMemory() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +BOOL SvMemoryStream::AllocateMemory( ULONG nNewSize ) +{ + pBuf = (BYTE*)SvMemAlloc( nNewSize, MEM_NOCALLNEWHDL ); + return( pBuf != 0 ); +} + +/************************************************************************* +|* +|* SvMemoryStream::ReAllocateMemory() (Bozo-Algorithmus) +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 20.06.94 +|* Letzte Aenderung OV 20.06.94 +|* +*************************************************************************/ + +BOOL SvMemoryStream::ReAllocateMemory( long nDiff ) +{ + BOOL bRetVal = FALSE; + long nTemp = (long)nSize; + nTemp += nDiff; + ULONG nNewSize = (ULONG)nTemp; + + if( nNewSize ) + { + BYTE* pNewBuf = (BYTE *) SvMemAlloc( nNewSize,MEM_NOCALLNEWHDL ); + + if( pNewBuf ) + { + bRetVal = TRUE; // Success! + if( nNewSize < nSize ) // Verkleinern ? + { +#ifdef WIN + hmemcpy((void _huge*)pNewBuf,(void _huge*)pBuf,(long)nNewSize ); +#else + memcpy( pNewBuf, pBuf, (size_t)nNewSize ); +#endif + if( nPos > nNewSize ) + nPos = 0L; + if( nEndOfData >= nNewSize ) + nEndOfData = nNewSize-1L; + } + else + { +#ifdef WIN + hmemcpy( (void _huge*)pNewBuf, (void _huge*)pBuf, (long)nSize ); +#else + memcpy( pNewBuf, pBuf, (size_t)nSize ); +#endif + } + + FreeMemory(); + + pBuf = pNewBuf; + nSize = nNewSize; + } + } + else + { + bRetVal = TRUE; + pBuf = 0; + nSize = 0; + nEndOfData = 0; + nPos = 0; + } + + return bRetVal; +} + +void SvMemoryStream::FreeMemory() +{ + SvMemFree( pBuf ); +} + +/************************************************************************* +|* +|* SvMemoryStream::SwitchBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 26.07.94 +|* Letzte Aenderung OV 26.07.94 +|* +*************************************************************************/ + +void* SvMemoryStream::SwitchBuffer( ULONG nInitSize, ULONG nResizeOffset) +{ + Flush(); + if( !bOwnsData ) + return 0; + Seek( STREAM_SEEK_TO_BEGIN ); + + void* pRetVal = pBuf; + pBuf = 0; + nEndOfData = 0L; + nResize = nResizeOffset; + nPos = 0; + + if( nResize != 0 && nResize < 16 ) + nResize = 16; + + ResetError(); + + if( nInitSize && !AllocateMemory(nInitSize) ) + { + SetError( SVSTREAM_OUTOFMEMORY ); + nSize = 0; + } + else + nSize = nInitSize; + + SetBufferSize( 64 ); + return pRetVal; +} + +void SvMemoryStream::SetSize( ULONG nNewSize ) +{ + long nDiff = (long)nNewSize - (long)nSize; + ReAllocateMemory( nDiff ); +} + +// ********************************************************************* +// Mac implementierung (mit Handles) in StrmMac.cxx +// ********************************************************************* + +#ifndef MAC + +/************************************************************************* +|* +|* SvSharedMemoryStream::SvSharedMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +SvSharedMemoryStream::SvSharedMemoryStream( void* pBuffer,ULONG nBufSize, + StreamMode eMode ) : + SvMemoryStream( (char*)pBuffer, nBufSize, eMode ) +{ + aHandle = 0; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::SvSharedMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +SvSharedMemoryStream::SvSharedMemoryStream( ULONG nInitSize, + ULONG nResizeOffset) : + SvMemoryStream( (void*)NULL ) +{ + if( !nInitSize ) + nInitSize = 1024; + + aHandle = 0; + bIsWritable = TRUE; + bOwnsData = TRUE; + nEndOfData = 0L; + nResize = nResizeOffset; + nPos = 0; + pBuf = 0; + + if( nResize != 0 && nResize < 16 ) + nResize = 16; + + if( nInitSize && !AllocateMemory( nInitSize ) ) + { + SetError( SVSTREAM_OUTOFMEMORY ); + nSize = 0; + } + else + nSize = nInitSize; + + SetBufferSize( 64 ); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::~SvSharedMemoryStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +SvSharedMemoryStream::~SvSharedMemoryStream() +{ + if( bOwnsData ) + { + FreeMemory(); + pBuf = 0; // damit der Dtor von SvMemoryStream nicht mehr zuschlaegt + } + else + Flush(); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::GetData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +const void* SvSharedMemoryStream::GetData() +{ + Flush(); + return pBuf; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::operator const char*() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvSharedMemoryStream::operator const void*() +{ + Flush(); + return pBuf; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +USHORT SvSharedMemoryStream::IsA() const +{ + return (USHORT)ID_SHAREDMEMORYSTREAM; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::SwitchBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung KH 16.06.95 +|* Letzte Aenderung KH 16.06.95 +|* +*************************************************************************/ + +void* SvSharedMemoryStream::SwitchBuffer( ULONG nInitSize, ULONG nResize ) +{ + return (void*)SvMemoryStream::SwitchBuffer(nInitSize, nResize); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::SetBuffer() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung KH 16.06.95 +|* Letzte Aenderung KH 16.06.95 +|* +*************************************************************************/ + +void* SvSharedMemoryStream::SetBuffer( void* pBuf, ULONG nSize, BOOL bOwnsData, + ULONG nEof) +{ + return (void*)SvMemoryStream::SetBuffer((char*)pBuf,nSize,bOwnsData,nEof); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::GetData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung KH 19.06.95 +|* Letzte Aenderung KH 19.06.95 +|* +*************************************************************************/ + +ULONG SvSharedMemoryStream::GetData( void* pData, ULONG nCount ) +{ + return SvMemoryStream::GetData(pData, nCount); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung KH 19.06.95 +|* Letzte Aenderung KH 19.06.95 +|* +*************************************************************************/ + +ULONG SvSharedMemoryStream::PutData( const void* pData, ULONG nCount ) +{ + return SvMemoryStream::PutData(pData, nCount); +} + + +// +// Speicherverwaltung (Alloc, Free, Realloc, SetHandle) +// Standardimplementation DOS & UNIX +// + +#if defined(DOS) || defined(UNX) + +/************************************************************************* +|* +|* SvSharedMemoryStream::SetHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 05.10.95 +|* Letzte Aenderung OV 05.10.95 +|* +*************************************************************************/ + +void* SvSharedMemoryStream::SetHandle( void* aHandle, ULONG nSize, + BOOL bOwnsData, ULONG nEOF) +{ + DBG_ERROR("SvSharedMemoryStream::SetHandle not implemented"); + return 0; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::AllocateMemory() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::AllocateMemory( ULONG nNewSize ) +{ + pBuf = new BYTE[ nNewSize ]; + return( pBuf != 0 ); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::ReAllocateMemory() (Bozo-Algorithmus) +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::ReAllocateMemory( long nDiff ) +{ + BOOL bRetVal = FALSE; + ULONG nNewSize = nSize + nDiff; + if( nNewSize ) + { + BYTE* pNewBuf = new BYTE[ nNewSize ]; + if( pNewBuf ) + { + bRetVal = TRUE; // Success! + if( nNewSize < nSize ) // Verkleinern ? + { + memcpy( pNewBuf, pBuf, (size_t)nNewSize ); + if( nPos > nNewSize ) + nPos = 0L; + if( nEndOfData >= nNewSize ) + nEndOfData = nNewSize-1L; + } + else + memcpy( pNewBuf, pBuf, (size_t)nSize ); + + FreeMemory(); + + pBuf = pNewBuf; + nSize = nNewSize; + } + } + else + { + FreeMemory(); + bRetVal = TRUE; + pBuf = 0; + nSize = 0; + nPos = 0; + nEndOfData = 0; + } + return bRetVal; +} + +void SvSharedMemoryStream::FreeMemory() +{ + delete pBuf; +} + + +#endif + +#endif + +TYPEINIT0 ( SvDataCopyStream ) + +// -------------------- + +// Diese Methoden muessen fuer die Win16-Version implementiert werden, +// da sonst der Compiler Aerger macht. (?) +/* +TypeId SvDataCopyStream::Type() const +{ + return 0; +} + +BOOL SvDataCopyStream::IsA(TypeId aId) const +{ + return FALSE; +} +*/ + +void SvDataCopyStream::Assign( const SvDataCopyStream& rHack) +{ +} diff --git a/tools/source/stream/strmos2.cxx b/tools/source/stream/strmos2.cxx new file mode 100644 index 000000000000..7f96a70ba194 --- /dev/null +++ b/tools/source/stream/strmos2.cxx @@ -0,0 +1,870 @@ +/************************************************************************* + * + * $RCSfile: strmos2.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <string.h> +#include <limits.h> + +#define INCL_PM +#define INCL_DOS +#include <svpm.h> +#include <bseerr.h> + +#include <debug.hxx> +#include <fsys.hxx> +#include <stream.hxx> +#include <fastfsys.hxx> + +// ----------------------------------------------------------------------- + +// -------------- +// - StreamData - +// -------------- + +class StreamData +{ +public: + HFILE hFile; + BOOL bIsEof; + + StreamData() + { + hFile = 0; + bIsEof = TRUE; + } +}; + +// ----------------------------------------------------------------------- + +ULONG GetSvError( APIRET nPMError ) +{ + static struct { APIRET pm; ULONG sv; } errArr[] = + { + { ERROR_FILE_NOT_FOUND, SVSTREAM_FILE_NOT_FOUND }, + { ERROR_PATH_NOT_FOUND, SVSTREAM_PATH_NOT_FOUND }, + { ERROR_TOO_MANY_OPEN_FILES, SVSTREAM_TOO_MANY_OPEN_FILES }, + { ERROR_ACCESS_DENIED, SVSTREAM_ACCESS_DENIED }, + { ERROR_INVALID_ACCESS, SVSTREAM_INVALID_ACCESS }, + { ERROR_SHARING_VIOLATION, SVSTREAM_SHARING_VIOLATION }, + { ERROR_SHARING_BUFFER_EXCEEDED,SVSTREAM_SHARE_BUFF_EXCEEDED }, + { ERROR_CANNOT_MAKE, SVSTREAM_CANNOT_MAKE }, + { ERROR_INVALID_PARAMETER, SVSTREAM_INVALID_PARAMETER }, + { ERROR_DRIVE_LOCKED, SVSTREAM_LOCKING_VIOLATION }, + { ERROR_LOCK_VIOLATION, SVSTREAM_LOCKING_VIOLATION }, + { ERROR_FILENAME_EXCED_RANGE, SVSTREAM_INVALID_PARAMETER }, + { ERROR_ATOMIC_LOCK_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER }, + { ERROR_READ_LOCKS_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER }, + + + { 0xFFFF, SVSTREAM_GENERALERROR } + }; + + ULONG nRetVal = SVSTREAM_GENERALERROR; // Standardfehler + int i=0; + do + { + if( errArr[i].pm == nPMError ) + { + nRetVal = errArr[i].sv; + break; + } + i++; + } + while( errArr[i].pm != 0xFFFF ); + return nRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +SvFileStream::SvFileStream( const String& rFileName, StreamMode nOpenMode ) +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + + SetBufferSize( 8192 ); + Open( rFileName, nOpenMode ); +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 22.11.94 +|* Letzte Aenderung OV 22.11.94 +|* +*************************************************************************/ + +SvFileStream::SvFileStream() +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + SetBufferSize( 8192 ); +} + +/************************************************************************* +|* +|* SvFileStream::~SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +SvFileStream::~SvFileStream() +{ + Close(); + if( pInstanceData ) + delete pInstanceData; +} + +/************************************************************************* +|* +|* SvFileStream::GetFileHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::GetFileHandle() const +{ + return (ULONG)pInstanceData->hFile; +} + +/************************************************************************* +|* +|* SvFileStream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +USHORT SvFileStream::IsA() const +{ + return ID_FILESTREAM; +} + +/************************************************************************* +|* +|* SvFileStream::GetData() +|* +|* Beschreibung STREAM.SDW, Prueft nicht Eof; IsEof danach rufbar +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::GetData( char* pData, ULONG nSize ) +{ +#ifdef DBG_UTIL + String aTraceStr( "SvFileStream::GetData(): " ); + aTraceStr += nSize; + aTraceStr += " Bytes from "; + aTraceStr += aFilename; + DBG_TRACE( aTraceStr ); +#endif + + ULONG nCount = 0L; + if( IsOpen() ) + { + APIRET nResult; + nResult = DosRead( pInstanceData->hFile,(PVOID)pData,nSize,&nCount ); + if( nResult ) + SetError(::GetSvError(nResult) ); + } + return nCount; +} + +/************************************************************************* +|* +|* SvFileStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::PutData( const char* pData, ULONG nSize ) +{ +#ifdef DBG_UTIL + String aTraceStr( "SvFileStrean::PutData: " ); + aTraceStr += nSize; + aTraceStr += " Bytes to "; + aTraceStr += aFilename; + DBG_TRACE( aTraceStr ); +#endif + + ULONG nCount = 0L; + if( IsOpen() ) + { + APIRET nResult; + nResult = DosWrite( pInstanceData->hFile,(PVOID)pData,nSize,&nCount ); + if( nResult ) + SetError(::GetSvError(nResult) ); + else if( !nCount ) + SetError( SVSTREAM_DISK_FULL ); + } + return nCount; +} + +/************************************************************************* +|* +|* SvFileStream::SeekPos() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::SeekPos( ULONG nPos ) +{ + ULONG nNewPos = 0L; + if( IsOpen() ) + { + APIRET nResult; + + if( nPos != STREAM_SEEK_TO_END ) + nResult = DosSetFilePtr( pInstanceData->hFile,(long)nPos, + FILE_BEGIN, &nNewPos ); + else + nResult = DosSetFilePtr( pInstanceData->hFile,0L, + FILE_END, &nNewPos ); + + if( nResult ) + SetError(::GetSvError(nResult) ); + } + else + SetError( SVSTREAM_GENERALERROR ); + return nNewPos; +} + +/************************************************************************* +|* +|* SvFileStream::Tell() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ +/* +ULONG SvFileStream::Tell() +{ + ULONG nPos = 0L; + + if( IsOpen() ) + { + APIRET nResult; + nResult = DosSetFilePtr(pInstanceData->hFile,0L,FILE_CURRENT,&nPos); + if( nResult ) + SetError(::GetSvError(nResult) ); + } + return nPos; +} +*/ + +/************************************************************************* +|* +|* SvFileStream::FlushData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::FlushData() +{ + if( IsOpen() ) + { + APIRET nResult; + nResult = DosResetBuffer(pInstanceData->hFile ); + if( nResult ) + SetError(::GetSvError(nResult) ); + } +} + +/************************************************************************* +|* +|* SvFileStream::LockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::LockRange( ULONG nByteOffset, ULONG nBytes ) +{ + BOOL bRetVal = FALSE; + if( IsOpen() ) + { + APIRET nResult; + FILELOCK aLockArea, aUnlockArea; + aUnlockArea.lOffset = 0L; + aUnlockArea.lRange = 0L; + aLockArea.lOffset = (long)nByteOffset; + aLockArea.lRange = (long)nBytes; + + nResult = DosSetFileLocks(pInstanceData->hFile, + &aUnlockArea, &aLockArea, + 1000UL, // Zeit in ms bis Abbruch + 0L // kein Atomic-Lock + ); + + if( nResult ) + SetError(::GetSvError(nResult) ); + else + bRetVal = TRUE; + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::UnlockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockRange( ULONG nByteOffset, ULONG nBytes ) +{ + BOOL bRetVal = FALSE; + if( IsOpen() ) + { + APIRET nResult; + FILELOCK aLockArea, aUnlockArea; + aLockArea.lOffset = 0L; + aLockArea.lRange = 0L; + aUnlockArea.lOffset = (long)nByteOffset; + aUnlockArea.lRange = (long)nBytes; + + nResult = DosSetFileLocks(pInstanceData->hFile, + &aUnlockArea, &aLockArea, + 1000UL, // Zeit in ms bis Abbruch + 0L // kein Atomic-Lock + ); + + if( nResult ) + SetError(::GetSvError(nResult) ); + else + bRetVal = TRUE; + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::LockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::LockFile() +{ + BOOL bRetVal = FALSE; + if( !nLockCounter ) + { + if( LockRange( 0L, LONG_MAX ) ) + { + nLockCounter = 1; + bRetVal = TRUE; + } + } + else + { + nLockCounter++; + bRetVal = TRUE; + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::UnlockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockFile() +{ + BOOL bRetVal = FALSE; + if( nLockCounter > 0) + { + if( nLockCounter == 1) + { + if( UnlockRange( 0L, LONG_MAX ) ) + { + nLockCounter = 0; + bRetVal = TRUE; + } + } + else + { + nLockCounter--; + bRetVal = TRUE; + } + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::Open() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL createLongNameEA ( const PCSZ pszPath, ULONG ulAttributes, const String& aLongName ); + +void SvFileStream::Open( const String& rFilename, StreamMode nOpenMode ) +{ + String aParsedFilename; + + if ( Folder::IsAvailable() && (rFilename.Search("{") < 9) ) + { + String aVirtualPart; + String aRealPart; + String aVirtualPath; + ItemIDPath aVirtualURL; + ULONG nDivider = 0; + + String aVirtualString(rFilename); + + for (int x=aVirtualString.Len(); x>0; x--) + { + if (aVirtualString.Copy(x,1).Compare("}")==COMPARE_EQUAL) + { + nDivider = x; + break; + } + } + + aVirtualPart = aVirtualString.Copy(0,nDivider+1); + aRealPart = aVirtualString.Copy(nDivider+2); + + aVirtualURL = aVirtualPart; + aVirtualPath = aVirtualURL.GetHostNotationPath(); + + DirEntry aTempDirEntry(aVirtualPath); + + aTempDirEntry += aRealPart; + + aParsedFilename = aTempDirEntry.GetFull(); + } + else + { + aParsedFilename = rFilename; + } + + Close(); + SvStream::ClearBuffer(); + + ULONG nActionTaken; + ULONG nOpenAction = 0L; + ULONG nShareBits = 0L; + ULONG nReadWriteBits = 0L; + + eStreamMode = nOpenMode; + eStreamMode &= ~STREAM_TRUNC; // beim ReOpen nicht cutten + + nOpenMode |= STREAM_SHARE_DENYNONE; // definierten Zustand garantieren + + // ********* Zugriffsflags *********** + if( nOpenMode & STREAM_SHARE_DENYNONE) + nShareBits = OPEN_SHARE_DENYNONE; + + if( nOpenMode & STREAM_SHARE_DENYREAD) + nShareBits = OPEN_SHARE_DENYREAD; + + if( nOpenMode & STREAM_SHARE_DENYWRITE) + nShareBits = OPEN_SHARE_DENYWRITE; + + if( nOpenMode & STREAM_SHARE_DENYALL) + nShareBits = OPEN_SHARE_DENYREADWRITE; + + if( (nOpenMode & STREAM_READ) ) + { + if( nOpenMode & STREAM_WRITE ) + nReadWriteBits |= OPEN_ACCESS_READWRITE; + else + { + nReadWriteBits |= OPEN_ACCESS_READONLY; + nOpenMode |= STREAM_NOCREATE; + } + } + else + nReadWriteBits |= OPEN_ACCESS_WRITEONLY; + + + if( nOpenMode & STREAM_NOCREATE ) + { + // Datei nicht erzeugen + nOpenAction = OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS; + } + else + { + // Datei erzeugen, wenn nicht vorhanden + nOpenAction = OPEN_ACTION_CREATE_IF_NEW; + if( nOpenMode & STREAM_TRUNC ) + // Auf Nullaenge kuerzen, wenn existiert + nOpenAction |= OPEN_ACTION_REPLACE_IF_EXISTS; + else + // Inhalt der Datei nicht wegwerfen + nOpenAction |= OPEN_ACTION_OPEN_IF_EXISTS; + } + + // + // resolves long FAT names used by OS2 + // + BOOL bIsLongOS2=FALSE; + if (Folder::IsAvailable()) + { + DirEntry aDirEntry(rFilename); + if (aDirEntry.IsLongNameOnFAT()) + { + // in kurzen Pfad wandeln + ItemIDPath aItemIDPath(rFilename); + aParsedFilename = aItemIDPath.GetHostNotationPath(); + bIsLongOS2 = TRUE; + } + } + + aFilename = aParsedFilename; + FSysRedirector::DoRedirect( aFilename ); + +#ifdef DBG_UTIL + String aTraceStr( "SvFileStream::Open(): " ); + aTraceStr += aFilename; + DBG_TRACE( aTraceStr ); +#endif + + APIRET nRet = DosOpen( (const char*)aFilename, &pInstanceData->hFile, + &nActionTaken, 0L, FILE_NORMAL, nOpenAction, + nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L); + + if( nRet == ERROR_TOO_MANY_OPEN_FILES ) + { + long nToAdd = 10; + ULONG nCurMaxFH; + nRet = DosSetRelMaxFH( &nToAdd, &nCurMaxFH ); + nRet = DosOpen( (const char*)aFilename, &pInstanceData->hFile, + &nActionTaken, 0L, FILE_NORMAL, nOpenAction, + nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L); + } + + // Bei Fehler pruefen, ob wir lesen duerfen + if( nRet==ERROR_ACCESS_DENIED || nRet==ERROR_SHARING_VIOLATION ) + { + nReadWriteBits = OPEN_ACCESS_READONLY; + nRet = DosOpen( (const char*)aFilename, &pInstanceData->hFile, + &nActionTaken, 0L, FILE_NORMAL, nOpenAction, + nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L); + } + + if( nRet ) + { + bIsOpen = FALSE; + SetError(::GetSvError(nRet) ); + } + else + { + bIsOpen = TRUE; + pInstanceData->bIsEof = FALSE; + if( nReadWriteBits != OPEN_ACCESS_READONLY ) + bIsWritable = TRUE; + } + + if (bIsOpen && bIsLongOS2) + { + //file schließen, da sonst createLongName u.U. nicht möglich + Close(); + + // erzeugtem File langen Namen geben + DirEntry aDirEntry(rFilename); + createLongNameEA((const char*)aFilename, FILE_NORMAL, aDirEntry.GetName()); + + // und wieder oeffnen + ReOpen(); + } + +} + +/************************************************************************* +|* +|* SvFileStream::ReOpen() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ReOpen() +{ + if( !bIsOpen && aFilename.Len() ) + Open( aFilename, eStreamMode ); +} + +/************************************************************************* +|* +|* SvFileStream::Close() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::Close() +{ + if( IsOpen() ) + { +#ifdef DBG_UTIL + String aTraceStr( "SvFileStream::Close(): " ); + aTraceStr += aFilename; + DBG_TRACE( aTraceStr ); +#endif + + if( nLockCounter ) + { + nLockCounter = 1; + UnlockFile(); + } + Flush(); + DosClose( pInstanceData->hFile ); + } + + bIsOpen = FALSE; + nLockCounter= 0; + bIsWritable = FALSE; + pInstanceData->bIsEof = TRUE; + SvStream::ClearBuffer(); + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvFileStream::ResetError() +|* +|* Beschreibung STREAM.SDW; Setzt Filepointer auf Dateianfang +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ResetError() +{ + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvFileStream::SetSize() +|* +|* Beschreibung +|* Ersterstellung OV 19.10.95 +|* Letzte Aenderung OV 19.10.95 +|* +*************************************************************************/ + +void SvFileStream::SetSize( ULONG nSize ) +{ + if( IsOpen() ) + { + APIRET nRet = DosSetFileSize( pInstanceData->hFile, nSize ); + if( nRet ) + SetError( ::GetSvError( nRet ) ); + } +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::AllocateMemory() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::AllocateMemory( ULONG nNewSize ) +{ + DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2"); + DBG_ASSERT(nNewSize,"Cannot allocate zero Bytes"); + APIRET nRet = DosAllocSharedMem( (void**)&pBuf, (PSZ)NULL, nNewSize, + PAG_READ | PAG_WRITE | PAG_COMMIT | + OBJ_GIVEABLE | OBJ_GETTABLE ); + return( nRet == 0 ); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::ReAllocateMemory() (Bozo-Algorithmus) +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::ReAllocateMemory( long nDiff ) +{ + DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2"); + BOOL bRetVal = FALSE; + ULONG nNewSize = nSize + nDiff; + if( nNewSize ) + { + // neuen Speicher nicht ueber AllocateMemory holen, da wir den + // alten Speicher behalten wollen, falls nicht genuegend Platz + // fuer den neuen Block da ist + char* pNewBuf; + APIRET nRet = DosAllocSharedMem( (void**)&pNewBuf,(PSZ)NULL,nNewSize, + PAG_READ | PAG_WRITE | PAG_COMMIT | + OBJ_GIVEABLE | OBJ_GETTABLE ); + DBG_ASSERT(!nRet,"DosAllocSharedMem failed"); + + if( !nRet ) + { + bRetVal = TRUE; // Success! + if( nNewSize < nSize ) // Verkleinern ? + { + memcpy( pNewBuf, pBuf, (size_t)nNewSize ); + if( nPos > nNewSize ) + nPos = 0L; + if( nEndOfData >= nNewSize ) + nEndOfData = nNewSize-1L; + } + else + memcpy( pNewBuf, pBuf, (size_t)nSize ); + + FreeMemory(); // den alten Block loeschen ... + + // und den neuen Block in Dienst stellen + pBuf = pNewBuf; + nSize = nNewSize; + } + } + else + { + bRetVal = TRUE; + FreeMemory(); + pBuf = 0; + nSize = 0; + nEndOfData = 0; + } + return bRetVal; +} + +void SvSharedMemoryStream::FreeMemory() +{ + DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2"); + DosFreeMem( pBuf ); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::SetHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 05.10.95 +|* Letzte Aenderung OV 05.10.95 +|* +*************************************************************************/ + +void* SvSharedMemoryStream::SetHandle( void*, ULONG,BOOL, ULONG ) +{ + DBG_ERROR("OS/2 does not support memory handles"); + // return SetBuffer(aNewHandle, nSize, bOwnsData, nEOF ); + return 0; +} + + diff --git a/tools/source/stream/strmsys.cxx b/tools/source/stream/strmsys.cxx new file mode 100644 index 000000000000..5639174d3fec --- /dev/null +++ b/tools/source/stream/strmsys.cxx @@ -0,0 +1,74 @@ +/************************************************************************* + * + * $RCSfile: strmsys.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#if defined( OS2 ) +#include "strmos2.cxx" +#elif defined( WNT ) +#include "strmwnt.cxx" +#elif defined( WIN ) +#include "strmwin.cxx" +#elif defined( MAC ) +#include "strmmac.cxx" +#elif defined( UNX ) +#include "strmunx.cxx" +#else +#include "strmstd.cxx" +#endif diff --git a/tools/source/stream/strmunx.cxx b/tools/source/stream/strmunx.cxx new file mode 100644 index 000000000000..cab977989456 --- /dev/null +++ b/tools/source/stream/strmunx.cxx @@ -0,0 +1,897 @@ +/************************************************************************* + * + * $RCSfile: strmunx.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdio.h> +#include <string.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <unistd.h> +#include <limits.h> +#include <stdlib.h> // fuer getenv() + +#include <debug.hxx> +#include <fsys.hxx> +#include <stream.hxx> + +#include <vos/mutex.hxx> +#include <osl/thread.h> // osl_getThreadTextEncoding + +// class FileBase +#ifndef _OSL_FILE_HXX_ +#include <osl/file.hxx> +#endif +using namespace osl; + +// ----------------------------------------------------------------------- + +// ---------------- +// - InternalLock - +// ---------------- + +class InternalStreamLock; +DECLARE_LIST( InternalStreamLockList, InternalStreamLock* ); + +class InternalStreamLock +{ + ULONG m_nStartPos; + ULONG m_nEndPos; + SvFileStream* m_pStream; + struct stat m_aStat; + + static InternalStreamLockList LockList; +#ifndef BOOTSTRAP + static NAMESPACE_VOS(OMutex) LockMutex; +#endif + + InternalStreamLock( ULONG, ULONG, SvFileStream* ); + ~InternalStreamLock(); +public: + static BOOL LockFile( ULONG nStart, ULONG nEnd, SvFileStream* ); + static void UnlockFile( ULONG nStart, ULONG nEnd, SvFileStream* ); +}; + +InternalStreamLockList InternalStreamLock::LockList; +#ifndef BOOTSTRAP +NAMESPACE_VOS(OMutex) InternalStreamLock::LockMutex; +#endif + +InternalStreamLock::InternalStreamLock( + ULONG nStart, + ULONG nEnd, + SvFileStream* pStream ) : + m_nStartPos( nStart ), + m_nEndPos( nEnd ), + m_pStream( pStream ) +{ + ByteString aFileName(m_pStream->GetFileName(), osl_getThreadTextEncoding()); + stat( aFileName.GetBuffer(), &m_aStat ); + LockList.Insert( this, LIST_APPEND ); +#ifdef DEBUG + fprintf( stderr, "locked %s", aFileName.GetBuffer() ); + if( m_nStartPos || m_nEndPos ) + fprintf(stderr, " [ %d ... %d ]", m_nStartPos, m_nEndPos ); + fprintf( stderr, "\n" ); +#endif +} + +InternalStreamLock::~InternalStreamLock() +{ + LockList.Remove( this ); +#ifdef DEBUG + ByteString aFileName(m_pStream->GetFileName(), osl_getThreadTextEncoding()); + fprintf( stderr, "unlocked %s", aFileName.GetBuffer() ); + if( m_nStartPos || m_nEndPos ) + fprintf(stderr, " [ %d ... %d ]", m_nStartPos, m_nEndPos ); + fprintf( stderr, "\n" ); +#endif +} + +BOOL InternalStreamLock::LockFile( ULONG nStart, ULONG nEnd, SvFileStream* pStream ) +{ +#ifndef BOOTSTRAP + NAMESPACE_VOS( OGuard ) aGuard( LockMutex ); +#endif + ByteString aFileName(pStream->GetFileName(), osl_getThreadTextEncoding()); + struct stat aStat; + if( stat( aFileName.GetBuffer(), &aStat ) ) + return FALSE; + + if( S_ISDIR( aStat.st_mode ) ) + return TRUE; + + InternalStreamLock* pLock = NULL; + for( int i = 0; i < LockList.Count(); i++ ) + { + pLock = LockList.GetObject( i ); + if( aStat.st_ino == pLock->m_aStat.st_ino ) + { + BOOL bDenyByOptions = FALSE; + StreamMode nLockMode = pLock->m_pStream->GetStreamMode(); + StreamMode nNewMode = pStream->GetStreamMode(); + + if( nLockMode & STREAM_SHARE_DENYALL ) + bDenyByOptions = TRUE; + else if( ( nLockMode & STREAM_SHARE_DENYWRITE ) && + ( nNewMode & STREAM_WRITE ) ) + bDenyByOptions = TRUE; + else if( ( nLockMode & STREAM_SHARE_DENYREAD ) && + ( nNewMode & STREAM_READ ) ) + bDenyByOptions = TRUE; + + if( bDenyByOptions ) + { + if( pLock->m_nStartPos == 0 && pLock->m_nEndPos == 0 ) // whole file is already locked + return FALSE; + if( nStart == 0 && nEnd == 0) // cannot lock whole file + return FALSE; + + if( ( nStart < pLock->m_nStartPos && nEnd > pLock->m_nStartPos ) || + ( nStart < pLock->m_nEndPos && nEnd > pLock->m_nEndPos ) ) + return FALSE; + } + } + } + pLock = new InternalStreamLock( nStart, nEnd, pStream ); + return TRUE; +} + +void InternalStreamLock::UnlockFile( ULONG nStart, ULONG nEnd, SvFileStream* pStream ) +{ +#ifndef BOOTSTRAP + NAMESPACE_VOS( OGuard ) aGuard( LockMutex ); +#endif + InternalStreamLock* pLock = NULL; + if( nStart == 0 && nEnd == 0 ) + { + for( int i = 0; i < LockList.Count(); i++ ) + { + if( ( pLock = LockList.GetObject( i ) )->m_pStream == pStream ) + { + delete pLock; + i--; + } + } + return; + } + for( int i = 0; i < LockList.Count(); i++ ) + { + if( ( pLock = LockList.GetObject( i ) )->m_pStream == pStream && + nStart == pLock->m_nStartPos && nEnd == pLock->m_nEndPos ) + { + delete pLock; + return; + } + } +} + +// -------------- +// - StreamData - +// -------------- + +class StreamData +{ +public: + int nHandle; + + StreamData() { nHandle = 0; } +}; + +// ----------------------------------------------------------------------- + +static ULONG GetSvError( int nErrno ) +{ + static struct { int nErr; ULONG sv; } errArr[] = + { + { 0, SVSTREAM_OK }, + { EACCES, SVSTREAM_ACCESS_DENIED }, + { EBADF, SVSTREAM_INVALID_HANDLE }, +#if defined( RS6000 ) || defined( ALPHA ) || defined( HP9000 ) || defined( NETBSD ) || defined( S390 ) || defined(FREEBSD) || defined(MACOSX) + { EDEADLK, SVSTREAM_LOCKING_VIOLATION }, +#else + { EDEADLOCK, SVSTREAM_LOCKING_VIOLATION }, +#endif + { EINVAL, SVSTREAM_INVALID_PARAMETER }, + { EMFILE, SVSTREAM_TOO_MANY_OPEN_FILES }, + { ENFILE, SVSTREAM_TOO_MANY_OPEN_FILES }, + { ENOENT, SVSTREAM_FILE_NOT_FOUND }, + { EPERM, SVSTREAM_ACCESS_DENIED }, + { EROFS, SVSTREAM_ACCESS_DENIED }, + { EAGAIN, SVSTREAM_LOCKING_VIOLATION }, + { EISDIR, SVSTREAM_PATH_NOT_FOUND }, + { ELOOP, SVSTREAM_PATH_NOT_FOUND }, +#if ! defined( RS6000 ) && ! defined( ALPHA ) && ! defined( NETBSD ) && ! defined (FREEBSD) && ! defined (MACOSX) + { EMULTIHOP, SVSTREAM_PATH_NOT_FOUND }, + { ENOLINK, SVSTREAM_PATH_NOT_FOUND }, +#endif + { ENOTDIR, SVSTREAM_PATH_NOT_FOUND }, + { ETXTBSY, SVSTREAM_ACCESS_DENIED }, + { EEXIST, SVSTREAM_CANNOT_MAKE }, + { ENOSPC, SVSTREAM_DISK_FULL }, + { (int)0xFFFF, SVSTREAM_GENERALERROR } + }; + + ULONG nRetVal = SVSTREAM_GENERALERROR; // Standardfehler + int i=0; + do + { + if ( errArr[i].nErr == nErrno ) + { + nRetVal = errArr[i].sv; + break; + } + i++; + } + while( errArr[i].nErr != 0xFFFF ); + return nRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 08.06.94 +|* Letzte Aenderung OV 08.06.94 +|* +*************************************************************************/ + +SvFileStream::SvFileStream( const String& rFileName, StreamMode nOpenMode ) +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + + SetBufferSize( 1024 ); + // convert URL to SystemPath, if necessary + ::rtl::OUString aFileName, aNormPath; + if ( FileBase::getNormalizedPathFromFileURL( rFileName, aNormPath ) == FileBase::E_None ) + FileBase::getSystemPathFromNormalizedPath( aNormPath, aFileName ); + else + aFileName = rFileName; + Open( aFileName, nOpenMode ); +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 22.11.94 +|* Letzte Aenderung OV 22.11.94 +|* +*************************************************************************/ + +SvFileStream::SvFileStream() +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + SetBufferSize( 1024 ); +} + +/************************************************************************* +|* +|* SvFileStream::~SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 22.11.94 +|* Letzte Aenderung OV 22.11.94 +|* +*************************************************************************/ + +SvFileStream::~SvFileStream() +{ + Close(); + + InternalStreamLock::UnlockFile( 0, 0, this ); + + if (pInstanceData) + delete pInstanceData; +} + +/************************************************************************* +|* +|* SvFileStream::GetFileHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 22.11.94 +|* Letzte Aenderung OV 22.11.94 +|* +*************************************************************************/ + +ULONG SvFileStream::GetFileHandle() const +{ + return (ULONG)pInstanceData->nHandle; +} + +/************************************************************************* +|* +|* SvFileStream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +USHORT SvFileStream::IsA() const +{ + return ID_FILESTREAM; +} + +/************************************************************************* +|* +|* SvFileStream::GetData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::GetData( void* pData, ULONG nSize ) +{ +#ifdef DBG_UTIL + ByteString aTraceStr( "SvFileStream::GetData(): " ); + aTraceStr += nSize; + aTraceStr += " Bytes from "; + aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding()); + DBG_TRACE( aTraceStr.GetBuffer() ); +#endif + + int nRead = 0; + if ( IsOpen() ) + { + nRead= read(pInstanceData->nHandle,pData,(unsigned)nSize); + if ( nRead == -1 ) + SetError( ::GetSvError( errno )); + } + return (ULONG)nRead; +} + +/************************************************************************* +|* +|* SvFileStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::PutData( const void* pData, ULONG nSize ) +{ +#ifdef DBG_UTIL + ByteString aTraceStr( "SvFileStrean::PutData: " ); + aTraceStr += nSize; + aTraceStr += " Bytes to "; + aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding()); + DBG_TRACE( aTraceStr.GetBuffer() ); +#endif + + int nWrite = 0; + if ( IsOpen() ) + { + nWrite= write(pInstanceData->nHandle,pData,(unsigned)nSize); + if ( nWrite == -1 ) + SetError( ::GetSvError( errno ) ); + else if( !nWrite ) + SetError( SVSTREAM_DISK_FULL ); + } + return (ULONG)nWrite; +} + +/************************************************************************* +|* +|* SvFileStream::SeekPos() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::SeekPos( ULONG nPos ) +{ + if ( IsOpen() ) + { + long nNewPos; + if ( nPos != STREAM_SEEK_TO_END ) + nNewPos = lseek( pInstanceData->nHandle, (long)nPos, SEEK_SET ); + else + nNewPos = lseek( pInstanceData->nHandle, 0L, SEEK_END ); + + if ( nNewPos == -1 ) + { + SetError( SVSTREAM_SEEK_ERROR ); + return 0L; + } + // langsam aber sicherer als return nNewPos + return lseek(pInstanceData->nHandle,0L,SEEK_CUR); + // return nNewPos; + } + SetError( SVSTREAM_GENERALERROR ); + return 0L; +} + + +/************************************************************************* +|* +|* SvFileStream::FlushData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::FlushData() +{ +// lokal gibt es nicht +} + +static char *pFileLockEnvVar = (char*)1; + +/************************************************************************* +|* +|* SvFileStream::LockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::LockRange( ULONG nByteOffset, ULONG nBytes ) +{ + struct flock aflock; + aflock.l_start = nByteOffset; + aflock.l_whence = SEEK_SET; + aflock.l_len = nBytes; + + int nLockMode = 0; + + if ( ! IsOpen() ) + return FALSE; + + if ( eStreamMode & STREAM_SHARE_DENYALL ) + if (bIsWritable) + nLockMode = F_WRLCK; + else + nLockMode = F_RDLCK; + + if ( eStreamMode & STREAM_SHARE_DENYREAD ) + if (bIsWritable) + nLockMode = F_WRLCK; + else + { + SetError(SVSTREAM_LOCKING_VIOLATION); + return FALSE; + } + + if ( eStreamMode & STREAM_SHARE_DENYWRITE ) + if (bIsWritable) + nLockMode = F_WRLCK; + else + nLockMode = F_RDLCK; + + if (!nLockMode) + return TRUE; + + if( ! InternalStreamLock::LockFile( nByteOffset, nByteOffset+nBytes, this ) ) + { +#ifdef DEBUG + fprintf( stderr, "InternalLock on %s [ %d ... %d ] failed\n", + ByteString(aFilename, osl_getThreadTextEncoding()).GetBuffer(), nByteOffset, nByteOffset+nBytes ); +#endif + return FALSE; + } + + // HACK: File-Locking nur via Environmentvariable einschalten + // um einen Haenger im Zusammenspiel mit einem Linux + // NFS-2-Server (kein Lockdaemon) zu verhindern. + // File-Locking ?ber NFS ist generell ein Performancekiller. + // HR, 22.10.1997 fuer SOLARIS + // CP, 30.11.1997 fuer HPUX + // ER, 18.12.1997 fuer IRIX + // HR, 18.05.1998 Environmentvariable + + if ( pFileLockEnvVar == (char*)1 ) + pFileLockEnvVar = getenv("STAR_ENABLE_FILE_LOCKING"); + if ( ! pFileLockEnvVar ) + return TRUE; + + aflock.l_type = nLockMode; + if (fcntl(pInstanceData->nHandle, F_GETLK, &aflock) == -1) + { + #if ( defined HPUX && defined BAD_UNION ) + #ifdef DBG_UTIL + fprintf( stderr, "***** FCNTL(lock):errno = %d\n", errno ); + #endif + if ( errno == EINVAL || errno == ENOSYS ) + return TRUE; + #endif + #if defined SINIX + if (errno == EINVAL) + return TRUE; + #endif + #if defined SOLARIS + if (errno == ENOSYS) + return TRUE; + #endif + SetError( ::GetSvError( errno )); + return FALSE; + } + if (aflock.l_type != F_UNLCK) + { + SetError(SVSTREAM_LOCKING_VIOLATION); + return FALSE; + } + + aflock.l_type = nLockMode; + if (fcntl(pInstanceData->nHandle, F_SETLK, &aflock) == -1) + { + SetError( ::GetSvError( errno )); + return FALSE; + } + return TRUE; +} + +/************************************************************************* +|* +|* SvFileStream::UnlockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockRange( ULONG nByteOffset, ULONG nBytes ) +{ + + struct flock aflock; + aflock.l_type = F_UNLCK; + aflock.l_start = nByteOffset; + aflock.l_whence = SEEK_SET; + aflock.l_len = nBytes; + + if ( ! IsOpen() ) + return FALSE; + + InternalStreamLock::UnlockFile( nByteOffset, nByteOffset+nBytes, this ); + + if ( ! (eStreamMode & + (STREAM_SHARE_DENYALL | STREAM_SHARE_DENYREAD | STREAM_SHARE_DENYWRITE))) + return TRUE; + + // wenn File Locking ausgeschaltet, siehe SvFileStream::LockRange + if ( ! pFileLockEnvVar ) + return TRUE; + + if (fcntl(pInstanceData->nHandle, F_SETLK, &aflock) != -1) + return TRUE; + +#if ( defined HPUX && defined BAD_UNION ) +#ifdef DBG_UTIL + fprintf( stderr, "***** FCNTL(unlock):errno = %d\n", errno ); +#endif + if ( errno == EINVAL || errno == ENOSYS ) + return TRUE; +#endif +#if ( defined SINIX ) + if (errno == EINVAL) + return TRUE; +#endif + + SetError( ::GetSvError( errno )); + return FALSE; +} + +/************************************************************************* +|* +|* SvFileStream::LockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::LockFile() +{ + return LockRange( 0UL, 0UL ); +} + +/************************************************************************* +|* +|* SvFileStream::UnlockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockFile() +{ + return UnlockRange( 0UL, 0UL ); +} + +/************************************************************************* +|* +|* SvFileStream::Open() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::Open( const String& rFilename, StreamMode nOpenMode ) +{ + int nAccess, nAccessRW; + int nMode; + int nHandleTmp; + struct stat buf; + BOOL bStatValid = FALSE; + + Close(); + errno = 0; + eStreamMode = nOpenMode; + eStreamMode &= ~STREAM_TRUNC; // beim ReOpen nicht cutten + +// !!! NoOp: Ansonsten ToAbs() verwendern +// !!! DirEntry aDirEntry( rFilename ); +// !!! aFilename = aDirEntry.GetFull(); + aFilename = rFilename; +#ifndef BOOTSTRAP + FSysRedirector::DoRedirect( aFilename ); +#endif + ByteString aLocalFilename(aFilename, osl_getThreadTextEncoding()); + +#ifdef DBG_UTIL + ByteString aTraceStr( "SvFileStream::Open(): " ); + aTraceStr += aLocalFilename; + DBG_TRACE( aTraceStr.GetBuffer() ); +#endif + + if ( lstat( aLocalFilename.GetBuffer(), &buf ) == 0 ) + { + bStatValid = TRUE; + // SvFileStream soll kein Directory oeffnen + if( S_ISDIR( buf.st_mode ) ) + { + SetError( ::GetSvError( EISDIR ) ); + return; + } + } + + + if ( !( nOpenMode & STREAM_WRITE ) ) + nAccessRW = O_RDONLY; + else if ( !( nOpenMode & STREAM_READ ) ) + nAccessRW = O_WRONLY; + else + nAccessRW = O_RDWR; + + nAccess = 0; + // Fix (MDA, 18.01.95): Bei RD_ONLY nicht mit O_CREAT oeffnen + // Wichtig auf Read-Only-Dateisystemen (wie CDROM) + if ( (!( nOpenMode & STREAM_NOCREATE )) && ( nAccessRW != O_RDONLY ) ) + nAccess |= O_CREAT; + if ( nOpenMode & STREAM_TRUNC ) + nAccess |= O_TRUNC; + + nMode = S_IREAD | S_IROTH | S_IRGRP; + if ( nOpenMode & STREAM_WRITE) + { + nMode |= (S_IWRITE | S_IWOTH | S_IWGRP); + + if ( nOpenMode & STREAM_COPY_ON_SYMLINK ) + { + if ( bStatValid && S_ISLNK( buf.st_mode ) < 0 ) + { + char *pBuf = new char[ 1024+1 ]; + if ( readlink( aLocalFilename.GetBuffer(), pBuf, 1024 ) > 0 ) + { + if ( unlink(aLocalFilename.GetBuffer()) == 0 ) + { +#ifdef DBG_UTIL + fprintf( stderr, + "Copying file on symbolic link (%s).\n", + aLocalFilename.GetBuffer() ); +#endif + String aTmpString( pBuf, osl_getThreadTextEncoding() ); + const DirEntry aSourceEntry( aTmpString ); + const DirEntry aTargetEntry( aFilename ); + FileCopier aFileCopier( aSourceEntry, aTargetEntry ); + aFileCopier.Execute(); + } + } + delete pBuf; + } + } + } + + + nHandleTmp = open(aLocalFilename.GetBuffer(),nAccessRW|nAccess, nMode ); + + if ( nHandleTmp == -1 ) + { + if ( nAccessRW != O_RDONLY ) + { + // auf Lesen runterschalten + nAccessRW = O_RDONLY; + nAccess = 0; + nMode = S_IREAD | S_IROTH | S_IRGRP; + nHandleTmp =open( aLocalFilename.GetBuffer(), + nAccessRW|nAccess, + nMode ); + } + } + if ( nHandleTmp != -1 ) + { + pInstanceData->nHandle = nHandleTmp; + bIsOpen = TRUE; + if ( nAccessRW != O_RDONLY ) + bIsWritable = TRUE; + + if ( !LockFile() ) // ganze Datei + { + close( nHandleTmp ); + bIsOpen = FALSE; + bIsWritable = FALSE; + pInstanceData->nHandle = 0; + } + } + else + SetError( ::GetSvError( errno ) ); +} + +/************************************************************************* +|* +|* SvFileStream::ReOpen() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ReOpen() +{ + if ( !bIsOpen && aFilename.Len() ) + Open( aFilename, eStreamMode ); +} + +/************************************************************************* +|* +|* SvFileStream::Close() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::Close() +{ + InternalStreamLock::UnlockFile( 0, 0, this ); + + if ( IsOpen() ) + { +#ifdef DBG_UTIL + ByteString aTraceStr( "SvFileStream::Close(): " ); + aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding()); + DBG_TRACE( aTraceStr.GetBuffer() ); +#endif + + Flush(); + close( pInstanceData->nHandle ); + pInstanceData->nHandle = 0; + } + + bIsOpen = FALSE; + bIsWritable = FALSE; + SvStream::ClearBuffer(); + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvFileStream::ResetError() +|* +|* Beschreibung STREAM.SDW; Setzt Filepointer auf Dateianfang +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ResetError() +{ + SvStream::ClearError(); +} + + +/************************************************************************* +|* +|* SvFileStream::SetSize() +|* +|* Beschreibung STREAM.SDW; +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::SetSize (ULONG nSize) +{ + if ( IsOpen() ) + { + if ( ftruncate ( pInstanceData->nHandle, (off_t) nSize ) == -1 ) + SetError ( ::GetSvError( errno )); + } +} + + diff --git a/tools/source/stream/strmwnt.cxx b/tools/source/stream/strmwnt.cxx new file mode 100644 index 000000000000..3d219a84bfd4 --- /dev/null +++ b/tools/source/stream/strmwnt.cxx @@ -0,0 +1,892 @@ +/************************************************************************* + * + * $RCSfile: strmwnt.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +/* + Todo: StreamMode <-> AllocateMemory +*/ + +#include <string.h> +#include <limits.h> + +#include <svwin.h> + +#include <debug.hxx> +#include <fsys.hxx> +#include <stream.hxx> + +// class FileBase +#ifndef _OSL_FILE_HXX_ +#include <osl/file.hxx> +#endif +using namespace osl; + +// ----------------------------------------------------------------------- + +// -------------- +// - StreamData - +// -------------- + +class StreamData +{ +public: + HANDLE hFile; + + StreamData() + { + hFile = 0; + } +}; + +// ----------------------------------------------------------------------- + +static ULONG GetSvError( DWORD nWntError ) +{ + static struct { DWORD wnt; ULONG sv; } errArr[] = + { + { ERROR_SUCCESS, SVSTREAM_OK }, + { ERROR_ACCESS_DENIED, SVSTREAM_ACCESS_DENIED }, + { ERROR_ACCOUNT_DISABLED, SVSTREAM_ACCESS_DENIED }, + { ERROR_ACCOUNT_EXPIRED, SVSTREAM_ACCESS_DENIED }, + { ERROR_ACCOUNT_RESTRICTION, SVSTREAM_ACCESS_DENIED }, + { ERROR_ATOMIC_LOCKS_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER }, + { ERROR_BAD_PATHNAME, SVSTREAM_PATH_NOT_FOUND }, + // Filename too long + { ERROR_BUFFER_OVERFLOW, SVSTREAM_INVALID_PARAMETER }, + { ERROR_DIRECTORY, SVSTREAM_INVALID_PARAMETER }, + { ERROR_DRIVE_LOCKED, SVSTREAM_LOCKING_VIOLATION }, + { ERROR_FILE_NOT_FOUND, SVSTREAM_FILE_NOT_FOUND }, + { ERROR_FILENAME_EXCED_RANGE, SVSTREAM_INVALID_PARAMETER }, + { ERROR_INVALID_ACCESS, SVSTREAM_INVALID_ACCESS }, + { ERROR_INVALID_DRIVE, SVSTREAM_PATH_NOT_FOUND }, + { ERROR_INVALID_HANDLE, SVSTREAM_INVALID_HANDLE }, + { ERROR_INVALID_NAME, SVSTREAM_PATH_NOT_FOUND }, + { ERROR_INVALID_PARAMETER, SVSTREAM_INVALID_PARAMETER }, + { ERROR_IS_SUBST_PATH, SVSTREAM_INVALID_PARAMETER }, + { ERROR_IS_SUBST_TARGET, SVSTREAM_INVALID_PARAMETER }, + { ERROR_LOCK_FAILED, SVSTREAM_LOCKING_VIOLATION }, + { ERROR_LOCK_VIOLATION, SVSTREAM_LOCKING_VIOLATION }, + { ERROR_NEGATIVE_SEEK, SVSTREAM_SEEK_ERROR }, + { ERROR_PATH_NOT_FOUND, SVSTREAM_PATH_NOT_FOUND }, + { ERROR_READ_FAULT, SVSTREAM_READ_ERROR }, + { ERROR_SEEK, SVSTREAM_SEEK_ERROR }, + { ERROR_SEEK_ON_DEVICE, SVSTREAM_SEEK_ERROR }, + { ERROR_SHARING_BUFFER_EXCEEDED,SVSTREAM_SHARE_BUFF_EXCEEDED }, + { ERROR_SHARING_PAUSED, SVSTREAM_SHARING_VIOLATION }, + { ERROR_SHARING_VIOLATION, SVSTREAM_SHARING_VIOLATION }, + { ERROR_TOO_MANY_OPEN_FILES, SVSTREAM_TOO_MANY_OPEN_FILES }, + { ERROR_WRITE_FAULT, SVSTREAM_WRITE_ERROR }, + { ERROR_WRITE_PROTECT, SVSTREAM_ACCESS_DENIED }, + { ERROR_DISK_FULL, SVSTREAM_DISK_FULL }, + + { (DWORD)0xFFFFFFFF, SVSTREAM_GENERALERROR } + }; + + ULONG nRetVal = SVSTREAM_GENERALERROR; // Standardfehler + int i=0; + do + { + if( errArr[i].wnt == nWntError ) + { + nRetVal = errArr[i].sv; + break; + } + i++; + } while( errArr[i].wnt != (DWORD)0xFFFFFFFF ); + return nRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 17.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +SvFileStream::SvFileStream( const String& rFileName, StreamMode nMode ) +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + + SetBufferSize( 8192 ); + // convert URL to SystemPath, if necessary + ::rtl::OUString aFileName, aNormPath; + if ( FileBase::getNormalizedPathFromFileURL( rFileName, aNormPath ) == FileBase::E_None ) + FileBase::getSystemPathFromNormalizedPath( aNormPath, aFileName ); + else + aFileName = rFileName; + Open( aFileName, nMode ); +} + +/************************************************************************* +|* +|* SvFileStream::SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 22.11.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +SvFileStream::SvFileStream() +{ + bIsOpen = FALSE; + nLockCounter = 0; + bIsWritable = FALSE; + pInstanceData = new StreamData; + + SetBufferSize( 8192 ); +} + +/************************************************************************* +|* +|* SvFileStream::~SvFileStream() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +SvFileStream::~SvFileStream() +{ + Close(); + if (pInstanceData) + delete pInstanceData; +} + +/************************************************************************* +|* +|* SvFileStream::GetFileHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +ULONG SvFileStream::GetFileHandle() const +{ + return (ULONG)pInstanceData->hFile; +} + +/************************************************************************* +|* +|* SvFileStream::IsA() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 14.06.94 +|* Letzte Aenderung OV 14.06.94 +|* +*************************************************************************/ + +USHORT SvFileStream::IsA() const +{ + return ID_FILESTREAM; +} + +/************************************************************************* +|* +|* SvFileStream::GetData() +|* +|* Beschreibung STREAM.SDW, Prueft nicht Eof; IsEof danach rufbar +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +ULONG SvFileStream::GetData( void* pData, ULONG nSize ) +{ + DWORD nCount = 0; + if( IsOpen() ) + { + BOOL bResult = ReadFile(pInstanceData->hFile,(LPVOID)pData,nSize,&nCount,NULL); + if( !bResult ) + { + ULONG nTestError = GetLastError(); + SetError(::GetSvError( nTestError ) ); + } + } + return (DWORD)nCount; +} + +/************************************************************************* +|* +|* SvFileStream::PutData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +ULONG SvFileStream::PutData( const void* pData, ULONG nSize ) +{ + DWORD nCount = 0; + if( IsOpen() ) + { + if(!WriteFile(pInstanceData->hFile,(LPVOID)pData,nSize,&nCount,NULL)) + SetError(::GetSvError( GetLastError() ) ); + } + return nCount; +} + +/************************************************************************* +|* +|* SvFileStream::SeekPos() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +ULONG SvFileStream::SeekPos( ULONG nPos ) +{ + DWORD nNewPos = 0; + if( IsOpen() ) + { + if( nPos != STREAM_SEEK_TO_END ) + // 64-Bit files werden nicht unterstuetzt + nNewPos=SetFilePointer(pInstanceData->hFile,nPos,NULL,FILE_BEGIN); + else + nNewPos=SetFilePointer(pInstanceData->hFile,0L,NULL,FILE_END); + + if( nNewPos == 0xFFFFFFFF ) + { + SetError(::GetSvError( GetLastError() ) ); + nNewPos = 0L; + } + } + else + SetError( SVSTREAM_GENERALERROR ); + return (ULONG)nNewPos; +} + +/************************************************************************* +|* +|* SvFileStream::Tell() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ +/* +ULONG SvFileStream::Tell() +{ + ULONG nPos = 0L; + + if( IsOpen() ) + { + DWORD nPos; + nPos = SetFilePointer(pInstanceData->hFile,0L,NULL,FILE_CURRENT); + if( nPos = 0xFFFFFFFF ) + { + SetError( ::GetSvError( GetLastError() ) ); + nPos = 0L; + } + } + return nPos; +} +*/ + +/************************************************************************* +|* +|* SvFileStream::FlushData() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +void SvFileStream::FlushData() +{ + if( IsOpen() ) + { + if( !FlushFileBuffers(pInstanceData->hFile) ) + SetError(::GetSvError(GetLastError())); + } +} + +/************************************************************************* +|* +|* SvFileStream::LockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +BOOL SvFileStream::LockRange( ULONG nByteOffset, ULONG nBytes ) +{ + BOOL bRetVal = FALSE; + if( IsOpen() ) + { + bRetVal = ::LockFile(pInstanceData->hFile,nByteOffset,0L,nBytes,0L ); + if( !bRetVal ) + SetError(::GetSvError(GetLastError())); + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::UnlockRange() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockRange( ULONG nByteOffset, ULONG nBytes ) +{ + BOOL bRetVal = FALSE; + if( IsOpen() ) + { + bRetVal = ::UnlockFile(pInstanceData->hFile,nByteOffset,0L,nBytes,0L ); + if( !bRetVal ) + SetError(::GetSvError(GetLastError())); + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::LockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::LockFile() +{ + BOOL bRetVal = FALSE; + if( !nLockCounter ) + { + if( LockRange( 0L, LONG_MAX ) ) + { + nLockCounter = 1; + bRetVal = TRUE; + } + } + else + { + nLockCounter++; + bRetVal = TRUE; + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvFileStream::UnlockFile() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +BOOL SvFileStream::UnlockFile() +{ + BOOL bRetVal = FALSE; + if( nLockCounter > 0) + { + if( nLockCounter == 1) + { + if( UnlockRange( 0L, LONG_MAX ) ) + { + nLockCounter = 0; + bRetVal = TRUE; + } + } + else + { + nLockCounter--; + bRetVal = TRUE; + } + } + return bRetVal; +} + + +/************************************************************************* +|* +|* SvFileStream::Open() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ +/* + NOCREATE TRUNC NT-Action + ---------------------------------------------- + 0 (Create) 0 OPEN_ALWAYS + 0 (Create) 1 CREATE_ALWAYS + 1 0 OPEN_EXISTING + 1 1 TRUNCATE_EXISTING +*/ + +void SvFileStream::Open( const String& rFilename, StreamMode nMode ) +{ + String aParsedFilename(rFilename); + + SetLastError( ERROR_SUCCESS ); + Close(); + SvStream::ClearBuffer(); + + eStreamMode = nMode; + eStreamMode &= ~STREAM_TRUNC; // beim ReOpen nicht cutten + + // !!! NoOp: Ansonsten ToAbs() verwendern + // !!! DirEntry aDirEntry( rFilename ); + // !!! aFilename = aDirEntry.GetFull(); + aFilename = aParsedFilename; +#ifdef BOOTSTRAP + ByteString aFileNameA( aFilename, gsl_getSystemTextEncoding()); +#else + ByteString aFileNameA( aFilename, osl_getThreadTextEncoding()); + FSysRedirector::DoRedirect( aFilename ); +#endif + SetLastError( ERROR_SUCCESS ); // ggf. durch Redirector geaendert! + + /* + #ifdef DBG_UTIL + String aTraceStr( "SvFileStream::Open(): " ); + aTraceStr += aFilename; + DBG_TRACE( aTraceStr ); + #endif + */ + + DWORD nOpenAction; + DWORD nShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + DWORD nAccessMode = 0L; + UINT nOldErrorMode = SetErrorMode( SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX ); + + if( nMode & STREAM_SHARE_DENYREAD) + nShareMode &= ~FILE_SHARE_READ; + + if( nMode & STREAM_SHARE_DENYWRITE) + nShareMode &= ~FILE_SHARE_WRITE; + + if( nMode & STREAM_SHARE_DENYALL) + nShareMode = 0; + + if( (nMode & STREAM_READ) ) + nAccessMode |= GENERIC_READ; + if( (nMode & STREAM_WRITE) ) + nAccessMode |= GENERIC_WRITE; + + if( nAccessMode == GENERIC_READ ) // ReadOnly ? + nMode |= STREAM_NOCREATE; // wenn ja, nicht erzeugen + + // Zuordnung siehe obige Wahrheitstafel + if( !(nMode & STREAM_NOCREATE) ) + { + if( nMode & STREAM_TRUNC ) + nOpenAction = CREATE_ALWAYS; + else + nOpenAction = OPEN_ALWAYS; + } + else + { + if( nMode & STREAM_TRUNC ) + nOpenAction = TRUNCATE_EXISTING; + else + nOpenAction = OPEN_EXISTING; + } + + pInstanceData->hFile = CreateFile( + aFileNameA.GetBuffer(), + nAccessMode, + nShareMode, + (LPSECURITY_ATTRIBUTES)NULL, + nOpenAction, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + (HANDLE) NULL + ); + + if( pInstanceData->hFile!=INVALID_HANDLE_VALUE && ( + // Hat Create Always eine existierende Datei ueberschrieben ? + GetLastError() == ERROR_ALREADY_EXISTS || + // Hat Open Always eine neue Datei angelegt ? + GetLastError() == ERROR_FILE_NOT_FOUND )) + { + // wenn ja, dann alles OK + if( nOpenAction == OPEN_ALWAYS || nOpenAction == CREATE_ALWAYS ) + SetLastError( ERROR_SUCCESS ); + } + + // Bei Fehler pruefen, ob wir lesen duerfen + if( (pInstanceData->hFile==INVALID_HANDLE_VALUE) && + (nAccessMode & GENERIC_WRITE)) + { + ULONG nErr = ::GetSvError( GetLastError() ); + if(nErr==SVSTREAM_ACCESS_DENIED || nErr==SVSTREAM_SHARING_VIOLATION) + { + nMode &= (~STREAM_WRITE); + nAccessMode = GENERIC_READ; + // OV, 28.1.97: Win32 setzt die Datei auf 0-Laenge, wenn + // die Openaction CREATE_ALWAYS ist!!!! + nOpenAction = OPEN_EXISTING; + SetLastError( ERROR_SUCCESS ); + pInstanceData->hFile = CreateFile( + aFileNameA.GetBuffer(), + GENERIC_READ, + nShareMode, + (LPSECURITY_ATTRIBUTES)NULL, + nOpenAction, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + (HANDLE) NULL + ); + if( GetLastError() == ERROR_ALREADY_EXISTS ) + SetLastError( ERROR_SUCCESS ); + } + } + + if( GetLastError() != ERROR_SUCCESS ) + { + bIsOpen = FALSE; + SetError(::GetSvError( GetLastError() ) ); + } + else + { + bIsOpen = TRUE; + // pInstanceData->bIsEof = FALSE; + if( nAccessMode & GENERIC_WRITE ) + bIsWritable = TRUE; + } + SetErrorMode( nOldErrorMode ); +} + +/************************************************************************* +|* +|* SvFileStream::ReOpen() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ReOpen() +{ + if( !bIsOpen && aFilename.Len() ) + Open( aFilename, eStreamMode ); +} + +/************************************************************************* +|* +|* SvFileStream::Close() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +void SvFileStream::Close() +{ + if( IsOpen() ) + { + if( nLockCounter ) + { + nLockCounter = 1; + UnlockFile(); + } + Flush(); + CloseHandle( pInstanceData->hFile ); + } + bIsOpen = FALSE; + nLockCounter= 0; + bIsWritable = FALSE; + SvStream::ClearBuffer(); + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvFileStream::ResetError() +|* +|* Beschreibung STREAM.SDW; Setzt Filepointer auf Dateianfang +|* Ersterstellung OV 15.06.94 +|* Letzte Aenderung OV 15.06.94 +|* +*************************************************************************/ + +void SvFileStream::ResetError() +{ + SvStream::ClearError(); +} + +/************************************************************************* +|* +|* SvFileStream::SetSize() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 19.10.95 +|* Letzte Aenderung TPF 15.07.98 +|* +*************************************************************************/ + +void SvFileStream::SetSize( ULONG nSize ) +{ + + if( IsOpen() ) + { + int bError = FALSE; + HANDLE hFile = pInstanceData->hFile; + ULONG nOld = SetFilePointer( hFile, 0L, NULL, FILE_CURRENT ); + if( nOld != 0xffffffff ) + { + if( SetFilePointer(hFile,nSize,NULL,FILE_BEGIN ) != 0xffffffff) + { + BOOL bSucc = SetEndOfFile( hFile ); + if( !bSucc ) + bError = TRUE; + } + if( SetFilePointer( hFile,nOld,NULL,FILE_BEGIN ) == 0xffffffff) + bError = TRUE; + } + if( bError ) + SetError(::GetSvError( GetLastError() ) ); + } +} + +/************************************************************************* +|* +|* ImpAlloc() +|* +|* Beschreibung Legt SharedMemory an +|* Ersterstellung OV 28.09.95 +|* Letzte Aenderung OV 28.09.95 +|* +*************************************************************************/ + +static BYTE* ImpAlloc( ULONG nSize, HANDLE& rHandle ) +{ + rHandle = 0; + HANDLE aHandle = CreateFileMapping((HANDLE)0xffffffff, + (LPSECURITY_ATTRIBUTES)0,PAGE_READWRITE,0,nSize,0); + if( !aHandle ) + return 0; + BYTE* pBuf = (BYTE*)MapViewOfFile(aHandle, FILE_MAP_ALL_ACCESS, 0, 0, 0); + if( !pBuf ) + { + CloseHandle( aHandle ); + return 0; + } + rHandle = aHandle; + return pBuf; +} + +/************************************************************************* +|* +|* ImpFree() +|* +|* Beschreibung Gibt SharedMemory frei +|* Ersterstellung OV 28.09.95 +|* Letzte Aenderung OV 28.09.95 +|* +*************************************************************************/ + +static void ImpFree( BYTE* pBuf, HANDLE aHandle ) +{ + if( pBuf ) + { + UnmapViewOfFile( pBuf ); + pBuf = 0; + } + CloseHandle( aHandle ); +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::AllocateMemory() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 28.09.95 +|* Letzte Aenderung OV 28.09.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::AllocateMemory( ULONG nNewSize ) +{ + HANDLE aWNTHandle; + pBuf = ImpAlloc( nNewSize, aWNTHandle ); + if( !pBuf ) + return FALSE; + aHandle = (void*)aWNTHandle; + return TRUE; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::ReAllocateMemory() +|* +|* Beschreibung STREAM.SDW (Bozo-Algorithmus) +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +BOOL SvSharedMemoryStream::ReAllocateMemory( long nDiff ) +{ + BOOL bRetVal = FALSE; + ULONG nNewSize = nSize + nDiff; + if( nNewSize ) + { + HANDLE aNewHandle; + BYTE* pNewBuf = ImpAlloc( nNewSize, aNewHandle ); + if( pNewBuf ) + { + bRetVal = TRUE; // Success! + if( nNewSize < nSize ) // Verkleinern ? + { + memcpy( pNewBuf, pBuf, (size_t)nNewSize ); + if( nPos > nNewSize ) + nPos = 0L; + if( nEndOfData >= nNewSize ) + nEndOfData = nNewSize-1L; + } + else + memcpy( pNewBuf, pBuf, (size_t)nSize ); + + ImpFree( pBuf, (HANDLE)aHandle ); + pBuf = pNewBuf; + nSize = nNewSize; + aHandle = (void*)aNewHandle; + } + } + else + { + FreeMemory(); + bRetVal = TRUE; + pBuf = 0; + nSize = 0; + nEndOfData = 0; + nPos = 0; + aHandle = 0; + } + return bRetVal; +} + +/************************************************************************* +|* +|* SvSharedMemoryStream::FreeMemory() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung CL 05.05.95 +|* Letzte Aenderung CL 05.05.95 +|* +*************************************************************************/ + +void SvSharedMemoryStream::FreeMemory() +{ + ImpFree( pBuf, (HANDLE)aHandle ); + aHandle = 0; +} + + +/************************************************************************* +|* +|* SvSharedMemoryStream::SetHandle() +|* +|* Beschreibung STREAM.SDW +|* Ersterstellung OV 05.10.95 +|* Letzte Aenderung OV 05.10.95 +|* +*************************************************************************/ + + +void* SvSharedMemoryStream::SetHandle( void* aNewHandle, ULONG nSize, + BOOL bOwnsData, ULONG nEOF ) +{ + void* pLocalBuf = MapViewOfFile(aNewHandle,FILE_MAP_ALL_ACCESS,0,0,0); + if( !pLocalBuf ) + { + SetError( SVSTREAM_OUTOFMEMORY ); + return 0; + } + if( aNewHandle == aHandle ) + { + // den aktuellen Handle temporaer auf Null setzen, damit FreeMemory + // (wird u.U. von SetBuffer aufgerufen) nicht den Handle schliesst, + // sondern nur die View loescht + aHandle = 0; + } + pLocalBuf = SetBuffer( pLocalBuf, nSize, bOwnsData, nEOF ); + aHandle = aNewHandle; + return pLocalBuf; +} + + diff --git a/tools/source/stream/vcompat.cxx b/tools/source/stream/vcompat.cxx new file mode 100644 index 000000000000..2e80897db707 --- /dev/null +++ b/tools/source/stream/vcompat.cxx @@ -0,0 +1,116 @@ +/************************************************************************* + * + * $RCSfile: vcompat.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#define _VCOMPAT_CXX + +#ifndef _STREAM_HXX +#include "stream.hxx" +#endif +#ifndef _VCOMPAT_HXX +#include "vcompat.hxx" +#endif + +// ----------------- +// - VersionCompat - +// ----------------- + +VersionCompat::VersionCompat( SvStream& rStm, USHORT nStreamMode, USHORT nVersion ) : + mpRWStm ( &rStm ), + mnStmMode ( nStreamMode ), + mnVersion ( nVersion ) +{ + if( !mpRWStm->GetError() ) + { + if( STREAM_WRITE == mnStmMode ) + { + *mpRWStm << mnVersion; + mnTotalSize = ( mnCompatPos = mpRWStm->Tell() ) + 4UL; + mpRWStm->SeekRel( 4L ); + } + else + { + *mpRWStm >> mnVersion; + *mpRWStm >> mnTotalSize; + mnCompatPos = mpRWStm->Tell(); + } + } +} + +// ------------------------------------------------------------------------ + +VersionCompat::~VersionCompat() +{ + if( STREAM_WRITE == mnStmMode ) + { + const UINT32 nEndPos = mpRWStm->Tell(); + + mpRWStm->Seek( mnCompatPos ); + *mpRWStm << ( nEndPos - mnTotalSize ); + mpRWStm->Seek( nEndPos ); + } + else + { + const UINT32 nReadSize = mpRWStm->Tell() - mnCompatPos; + + if( mnTotalSize > nReadSize ) + mpRWStm->SeekRel( mnTotalSize - nReadSize ); + } +} diff --git a/tools/source/string/makefile.mk b/tools/source/string/makefile.mk new file mode 100644 index 000000000000..a0005f53cec4 --- /dev/null +++ b/tools/source/string/makefile.mk @@ -0,0 +1,88 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=str + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/tstring.obj \ + $(SLO)$/tustring.obj \ + $(SLO)$/charset.obj + +.IF "$(UPDATER)"!="" +OBJFILES= $(OBJ)$/tstring.obj \ + $(OBJ)$/tustring.obj \ + $(OBJ)$/charset.obj +.ENDIF + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/string/strascii.cxx b/tools/source/string/strascii.cxx new file mode 100644 index 000000000000..9b54b920a2c2 --- /dev/null +++ b/tools/source/string/strascii.cxx @@ -0,0 +1,773 @@ +/************************************************************************* + * + * $RCSfile: strascii.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +// ======================================================================= + +#ifdef DBG_UTIL + +static BOOL ImplDbgCheckAsciiStr( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + while ( nLen && *pAsciiStr ) + { + if ( ((unsigned char)*pAsciiStr) > 127 ) + return FALSE; + pAsciiStr++; + nLen--; + } + + return TRUE; +} + +#endif + +// ======================================================================= + +static void ImplCopyAsciiStr( sal_Unicode* pDest, const sal_Char* pSrc, + xub_StrLen nLen ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pSrc, nLen ), + "UniString::CopyAsciiStr() - pAsciiStr include characters > 127" ); + + while ( nLen ) + { + *pDest = (unsigned char)*pSrc; + pDest++; + pSrc++; + nLen--; + } +} + +// ======================================================================= + +static sal_Int32 ImplStringCompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2 ) +{ + sal_Int32 nRet; + while ( ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) && + *pStr2 ) + { + pStr1++; + pStr2++; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringCompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; + while ( nCount && + ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) && + *pStr2 ) + { + pStr1++; + pStr2++; + nCount--; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringCompareWithoutZeroAscii( const sal_Unicode* pStr1, const sal_Char* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; + while ( nCount && + ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)((unsigned char)*pStr2))) == 0) ) + { + pStr1++; + pStr2++; + nCount--; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringICompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2 ) +{ + sal_Int32 nRet; + sal_Unicode c1; + sal_Char c2; + do + { + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + c1 = *pStr1; + c2 = *pStr2; + if ( (c1 >= 65) && (c1 <= 90) ) + c1 += 32; + if ( (c2 >= 65) && (c2 <= 90) ) + c2 += 32; + nRet = ((sal_Int32)c1)-((sal_Int32)((unsigned char)c2)); + if ( nRet != 0 ) + break; + + pStr1++; + pStr2++; + } + while ( c2 ); + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringICompareAscii( const sal_Unicode* pStr1, const sal_Char* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; + sal_Unicode c1; + sal_Char c2; + do + { + if ( !nCount ) + break; + + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + c1 = *pStr1; + c2 = *pStr2; + if ( (c1 >= 65) && (c1 <= 90) ) + c1 += 32; + if ( (c2 >= 65) && (c2 <= 90) ) + c2 += 32; + nRet = ((sal_Int32)c1)-((sal_Int32)((unsigned char)c2)); + if ( nRet != 0 ) + break; + + pStr1++; + pStr2++; + nCount--; + } + while ( c2 ); + + return nRet; +} + +// ======================================================================= + +UniString UniString::CreateFromAscii( const sal_Char* pAsciiStr ) +{ + DBG_ASSERT( pAsciiStr, "UniString::CreateFromAscii() - pAsciiStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nLen = ImplStringLen( pAsciiStr ); + + UniString aTempStr; + if ( nLen ) + { + if ( nLen > STRING_MAXLEN ) + nLen = STRING_MAXLEN; + ImplCopyAsciiStr( aTempStr.AllocBuffer( nLen ), pAsciiStr, nLen ); + } + return aTempStr; +} + +// ----------------------------------------------------------------------- + +UniString UniString::CreateFromAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_ASSERT( pAsciiStr, "UniString::CreateFromAscii() - pAsciiStr is NULL" ); + + // Stringlaenge ermitteln + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pAsciiStr ); + + UniString aTempStr; + + if ( nLen ) + { + if ( nLen > STRING_MAXLEN ) + nLen = STRING_MAXLEN; + ImplCopyAsciiStr( aTempStr.AllocBuffer( nLen ), pAsciiStr, nLen ); + } + return aTempStr; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::AssignAscii( const sal_Char* pAsciiStr ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::AssignAscii() - pAsciiStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nLen = ImplStringLen( pAsciiStr ); + + if ( !nLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + else + { + // Wenn String genauso lang ist, wie der String, dann direkt kopieren + if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) ) + ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen ); + else + { + // Alte Daten loeschen + ImplDeleteData( mpData ); + + // Daten initialisieren und String kopieren + mpData = ImplAllocData( nLen ); + ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen ); + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::AssignAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::AssignAscii() - pAsciiStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pAsciiStr ); + +#ifdef DBG_UTIL + if ( DbgIsAssert() ) + { + for ( xub_StrLen i = 0; i < nLen; i++ ) + { + if ( !pAsciiStr[i] ) + { + DBG_ERROR( "UniString::AssignAscii() : nLen is wrong" ); + } + } + } +#endif + + if ( !nLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + else + { + // Wenn String genauso lang ist, wie der String, dann direkt kopieren + if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) ) + ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen ); + else + { + // Alte Daten loeschen + ImplDeleteData( mpData ); + + // Daten initialisieren und String kopieren + mpData = ImplAllocData( nLen ); + ImplCopyAsciiStr( mpData->maStr, pAsciiStr, nLen ); + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::AppendAscii( const sal_Char* pAsciiStr ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::AppendAscii() - pAsciiStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nCopyLen = ImplStringLen( pAsciiStr ); + + // Ueberlauf abfangen + nCopyLen = ImplGetCopyLen( mpData->mnLen, nCopyLen ); + + // Ist es kein leerer String + if ( nCopyLen ) + { + // Neue Datenstruktur und neuen String erzeugen + UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, mpData->mnLen*sizeof( sal_Unicode ) ); + ImplCopyAsciiStr( pNewData->maStr+mpData->mnLen, pAsciiStr, nCopyLen ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::AppendAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::AppendAscii() - pAsciiStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pAsciiStr ); + +#ifdef DBG_UTIL + if ( DbgIsAssert() ) + { + for ( xub_StrLen i = 0; i < nLen; i++ ) + { + if ( !pAsciiStr[i] ) + { + DBG_ERROR( "UniString::AppendAscii() : nLen is wrong" ); + } + } + } +#endif + + // Ueberlauf abfangen + xub_StrLen nCopyLen = ImplGetCopyLen( mpData->mnLen, nLen ); + + // Ist es kein leerer String + if ( nCopyLen ) + { + // Neue Datenstruktur und neuen String erzeugen + UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, mpData->mnLen*sizeof( sal_Unicode ) ); + ImplCopyAsciiStr( pNewData->maStr+mpData->mnLen, pAsciiStr, nCopyLen ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::InsertAscii( const char* pAsciiStr, xub_StrLen nIndex ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::InsertAscii() - pAsciiStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nCopyLen = ImplStringLen( pAsciiStr ); + + // Ueberlauf abfangen + nCopyLen = ImplGetCopyLen( mpData->mnLen, nCopyLen ); + + // Ist der einzufuegende String ein Leerstring + if ( !nCopyLen ) + return *this; + + // Index groesser als Laenge + if ( nIndex > mpData->mnLen ) + nIndex = mpData->mnLen; + + // Neue Laenge ermitteln und neuen String anlegen + UniStringData* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( sal_Unicode ) ); + ImplCopyAsciiStr( pNewData->maStr+nIndex, pAsciiStr, nCopyLen ); + memcpy( pNewData->maStr+nIndex+nCopyLen, mpData->maStr+nIndex, + (mpData->mnLen-nIndex)*sizeof( sal_Unicode ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +UniString& UniString::ReplaceAscii( xub_StrLen nIndex, xub_StrLen nCount, + const sal_Char* pAsciiStr, xub_StrLen nStrLen ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( pAsciiStr, "UniString::ReplaceAscii() - pAsciiStr is NULL" ); + + // Wenn Index groessergleich Laenge ist, dann ist es ein Append + if ( nIndex >= mpData->mnLen ) + { + AppendAscii( pAsciiStr, nStrLen ); + return *this; + } + + // Ist es eine Zuweisung + if ( (nIndex == 0) && (nCount >= mpData->mnLen) ) + { + AssignAscii( pAsciiStr, nStrLen ); + return *this; + } + + // Reicht ein Erase + if ( nStrLen == STRING_LEN ) + nStrLen = ImplStringLen( pAsciiStr ); + if ( !nStrLen ) + return Erase( nIndex, nCount ); + + // nCount darf nicht ueber das Stringende hinnausgehen + if ( (ULONG)nIndex+nCount > mpData->mnLen ) + nCount = mpData->mnLen-nIndex; + + // Reicht eine zeichenweise Zuweisung + if ( nCount == nStrLen ) + { + ImplCopyData( this ); + ImplCopyAsciiStr( mpData->maStr+nIndex, pAsciiStr, nStrLen ); + return *this; + } + + // Ueberlauf abfangen + nStrLen = ImplGetCopyLen( mpData->mnLen-nCount, nStrLen ); + + // Neue Daten anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen-nCount+nStrLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + ImplCopyAsciiStr( pNewData->maStr+nIndex, pAsciiStr, nStrLen ); + memcpy( pNewData->maStr+nIndex+nStrLen, mpData->maStr+nIndex+nCount, + (mpData->mnLen-nIndex-nCount+1)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +StringCompare UniString::CompareToAscii( const sal_Char* pAsciiStr, + xub_StrLen nLen ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "UniString::CompareToAscii() - pAsciiStr include characters > 127" ); + + // String vergleichen + sal_Int32 nCompare = ImplStringCompareAscii( mpData->maStr, pAsciiStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +StringCompare UniString::CompareIgnoreCaseToAscii( const sal_Char* pAsciiStr, + xub_StrLen nLen ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "UniString::CompareIgnoreCaseToAscii() - pAsciiStr include characters > 127" ); + + // String vergleichen + sal_Int32 nCompare = ImplStringICompareAscii( mpData->maStr, pAsciiStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +BOOL UniString::EqualsAscii( const sal_Char* pAsciiStr ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "UniString::EqualsAscii() - pAsciiStr include characters > 127" ); + + return (ImplStringCompareAscii( mpData->maStr, pAsciiStr ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL UniString::EqualsIgnoreCaseAscii( const sal_Char* pAsciiStr ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "UniString::EqualsIgnoreCaseAscii() - pAsciiStr include characters > 127" ); + + return (ImplStringICompareAscii( mpData->maStr, pAsciiStr ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL UniString::EqualsAscii( const sal_Char* pAsciiStr, + xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "UniString::EqualsAscii() - pAsciiStr include characters > 127" ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (*pAsciiStr == 0); + + return (ImplStringCompareAscii( mpData->maStr+nIndex, pAsciiStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL UniString::EqualsIgnoreCaseAscii( const sal_Char* pAsciiStr, + xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "UniString::EqualsIgnoreCaseAscii() - pAsciiStr include characters > 127" ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (*pAsciiStr == 0); + + return (ImplStringICompareAscii( mpData->maStr+nIndex, pAsciiStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +xub_StrLen UniString::SearchAscii( const sal_Char* pAsciiStr, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "UniString::SearchAscii() - pAsciiStr include characters > 127" ); + + xub_StrLen nLen = mpData->mnLen; + xub_StrLen nStrLen = ImplStringLen( pAsciiStr ); + + // Falls die Laenge des uebergebenen Strings 0 ist oder der Index + // hinter dem String liegt, dann wurde der String nicht gefunden + if ( !nStrLen || (nIndex >= nLen) ) + return STRING_NOTFOUND; + + const sal_Unicode* pStr = mpData->maStr; + pStr += nIndex; + + if ( nStrLen == 1 ) + { + sal_Unicode cSearch = (unsigned char)*pAsciiStr; + while ( nIndex < nLen ) + { + if ( *pStr == cSearch ) + return nIndex; + pStr++; + nIndex++; + } + } + else + { + // Nur innerhalb des Strings suchen + while ( (ULONG)nIndex+nStrLen <= nLen ) + { + // Stimmt der String ueberein + if ( ImplStringCompareWithoutZeroAscii( pStr, pAsciiStr, nStrLen ) == 0 ) + return nIndex; + pStr++; + nIndex++; + } + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen UniString::SearchAndReplaceAscii( const sal_Char* pAsciiStr, const UniString& rRepStr, + xub_StrLen nIndex ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "UniString::SearchAndReplaceAscii() - pAsciiStr include characters > 127" ); + + xub_StrLen nSPos = SearchAscii( pAsciiStr, nIndex ); + if ( nSPos != STRING_NOTFOUND ) + Replace( nSPos, ImplStringLen( pAsciiStr ), rRepStr ); + + return nSPos; +} + +// ----------------------------------------------------------------------- + +void UniString::SearchAndReplaceAllAscii( const sal_Char* pAsciiStr, const UniString& rRepStr ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "UniString::SearchAndReplaceAllAscii() - pAsciiStr include characters > 127" ); + + xub_StrLen nCharLen = ImplStringLen( pAsciiStr ); + xub_StrLen nSPos = SearchAscii( pAsciiStr, 0 ); + while ( nSPos != STRING_NOTFOUND ) + { + Replace( nSPos, nCharLen, rRepStr ); + nSPos += rRepStr.Len(); + nSPos = SearchAscii( pAsciiStr, nSPos ); + } +} + +// ======================================================================= + +#ifndef ENABLEUNICODE + +ByteString ByteString::CreateFromAscii( const sal_Char* pAsciiStr ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "ByteString::CreateFromAscii() - pAsciiStr include characters > 127" ); + + return ByteString( pAsciiStr ); +} + +// ----------------------------------------------------------------------- + +ByteString ByteString::CreateFromAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "ByteString::CreateFromAscii() - pAsciiStr include characters > 127" ); + + return ByteString( pAsciiStr, nLen ); +} + +// ----------------------------------------------------------------------- + +ByteString& ByteString::AssignAscii( const sal_Char* pAsciiStr ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "ByteString::AssignAscii() - pAsciiStr include characters > 127" ); + + return Assign( pAsciiStr ); +} + +// ----------------------------------------------------------------------- + +ByteString& ByteString::AssignAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "ByteString::AssignAscii() - pAsciiStr include characters > 127" ); + + return Assign( pAsciiStr, nLen ); +} + +// ----------------------------------------------------------------------- + +ByteString& ByteString::AppendAscii( const sal_Char* pAsciiStr, xub_StrLen nLen ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "ByteString::AppendAscii() - pAsciiStr include characters > 127" ); + + return Append( pAsciiStr, nLen ); +} + +// ----------------------------------------------------------------------- + +StringCompare ByteString::CompareToAscii( const sal_Char* pAsciiStr, + xub_StrLen nLen ) const +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, nLen ), + "ByteString::CompareToAscii() - pAsciiStr include characters > 127" ); + + return CompareTo( pAsciiStr, nLen ); +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::EqualsAscii( const sal_Char* pAsciiStr ) const +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "ByteString::EqualsAscii() - pAsciiStr include characters > 127" ); + + return Equals( pAsciiStr ); +} + +// ----------------------------------------------------------------------- + +xub_StrLen ByteString::SearchAscii( const sal_Char* pAsciiStr, xub_StrLen nIndex ) const +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "ByteString::SearchAscii() - pAsciiStr include characters > 127" ); + + return Search( pAsciiStr, nIndex ); +} + +// ----------------------------------------------------------------------- + +xub_StrLen ByteString::SearchAndReplaceAscii( const sal_Char* pAsciiStr, const ByteString& rRepStr, + xub_StrLen nIndex ) +{ + DBG_ASSERT( ImplDbgCheckAsciiStr( pAsciiStr, STRING_LEN ), + "ByteString::SearchAscii() - pAsciiStr include characters > 127" ); + + return SearchAndReplace( pAsciiStr, rRepStr, nIndex ); +} + +#endif diff --git a/tools/source/string/strcvt.cxx b/tools/source/string/strcvt.cxx new file mode 100644 index 000000000000..cd6e84a918c8 --- /dev/null +++ b/tools/source/string/strcvt.cxx @@ -0,0 +1,757 @@ +/************************************************************************* + * + * $RCSfile: strcvt.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +// ======================================================================= + +static ByteStringData* ImplGetStringDataFromUniString( const sal_Unicode* pUniStr, sal_Size nUniLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_ASSERT( (eTextEncoding != 9) && + (eTextEncoding != RTL_TEXTENCODING_DONTKNOW) && + (eTextEncoding != RTL_TEXTENCODING_UCS2) && + (eTextEncoding != RTL_TEXTENCODING_UCS4), + "UniString-->ByteString: Wrong TextEncoding" ); + + if ( !nUniLen ) + { + ImplIncRefCount( &aImplEmptyStrData ); + return &aImplEmptyStrData; + } + +#ifndef NOOLDSTRING + if ( eTextEncoding == CHARSET_SYSTEM ) + eTextEncoding = GetSystemCharSet(); +#endif + nCvtFlags |= RTL_UNICODETOTEXT_FLAGS_FLUSH; + + ByteStringData* pData; + rtl_TextEncodingInfo aTextEncInfo; + rtl_UnicodeToTextConverter hConverter = rtl_createUnicodeToTextConverter( eTextEncoding ); + sal_uInt32 nInfo; + sal_Size nSrcChars; + sal_Size nDestBytes; + sal_Size nNewLen; + + // get TextEncodingInfo + aTextEncInfo.StructSize = sizeof( aTextEncInfo ); + rtl_getTextEncodingInfo( eTextEncoding, &aTextEncInfo ); + + // Zuerst konvertieren wir mit der wahrscheinlichen Anzahl + // der zu konvertierenden Zeichen + nNewLen = nUniLen*aTextEncInfo.AverageCharSize; + if ( nNewLen > STRING_MAXLEN ) + nNewLen = STRING_MAXLEN; + pData = ImplAllocData( (xub_StrLen)nNewLen ); + nDestBytes = rtl_convertUnicodeToText( hConverter, 0, + pUniStr, nUniLen, + (sal_Char*)pData->maStr, nNewLen, + nCvtFlags, + &nInfo, &nSrcChars ); + // Solange versuchen zu konvertieren, bis der Buffer ausreicht, oder + // die maximale Stringlaenge erreicht ist + while ( (nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL) && + (nNewLen != STRING_MAXLEN) ) + { + rtl_freeMemory( pData ); + + // Dann mit der maximalen Anzahl der Zeichen versuchen + // und etwas mehr Overhead geben, falls nicht zu konvertierende + // Zeichen durch mehrere Ersatzzeichen ersetzt werden + sal_Size nNotConvertedChars = nUniLen-nSrcChars; + nNewLen = nDestBytes+(nNotConvertedChars*aTextEncInfo.MaximumCharSize)+ + nNotConvertedChars+4; + if ( nNewLen > STRING_MAXLEN ) + nNewLen = STRING_MAXLEN; + pData = ImplAllocData( (xub_StrLen)nNewLen ); + nDestBytes = rtl_convertUnicodeToText( hConverter, 0, + pUniStr, nUniLen, + (sal_Char*)pData->maStr, nNewLen, + nCvtFlags, + &nInfo, &nSrcChars ); + } + + // String entsprechend der durch das Konvertieren tatsaechlich + // entstehenden Bytes anpassen + if ( !nDestBytes ) + { + rtl_freeMemory( pData ); + ImplIncRefCount( &aImplEmptyStrData ); + pData = &aImplEmptyStrData; + } + else if ( nNewLen > nDestBytes+8 ) + { + ByteStringData* pTempData = ImplAllocData( (xub_StrLen)nDestBytes ); + memcpy( pTempData->maStr, pData->maStr, nDestBytes ); + rtl_freeMemory( pData ); + pData = pTempData; + } + else + { + pData->mnLen = (xub_StrLen)nDestBytes; + pData->maStr[nDestBytes] = '\0'; + } + rtl_destroyUnicodeToTextConverter( hConverter ); + return pData; +} + +// ----------------------------------------------------------------------- + +static void ImplUpdateStringFromUniString( ByteString* pString, + const sal_Unicode* pUniStr, sal_Size nUniLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + ByteStringData* pNewStringData; + pNewStringData = ImplGetStringDataFromUniString( pUniStr, nUniLen, eTextEncoding, nCvtFlags ); + ImplDeleteData( pString->mpData ); + pString->mpData = pNewStringData; +} + +// ======================================================================= + +#ifndef ENABLEUNICODE +void ByteString::InitStringRes( const UniString& rUniStr ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString ); + + mpData = ImplGetStringDataFromUniString( rUniStr.mpData->maStr, rUniStr.mpData->mnLen, + gsl_getSystemTextEncoding(), + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE | + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR | + RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 | + RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE | + RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE ); +} +#endif + +// ======================================================================= + +ByteString::ByteString( const UniString& rUniStr, rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString ); + + mpData = ImplGetStringDataFromUniString( rUniStr.mpData->maStr, rUniStr.mpData->mnLen, + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +ByteString::ByteString( const UniString& rUniStr, xub_StrLen nPos, xub_StrLen nLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString ); + + // Stringlaenge ermitteln + if ( nPos > rUniStr.mpData->mnLen ) + nLen = 0; + else + { + // Laenge korrigieren, wenn noetig + xub_StrLen nMaxLen = rUniStr.mpData->mnLen-nPos; + if ( nLen > nMaxLen ) + nLen = nMaxLen; + } + + mpData = ImplGetStringDataFromUniString( rUniStr.mpData->maStr+nPos, nLen, + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +ByteString::ByteString( const sal_Unicode* pUniStr, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" ); + + mpData = ImplGetStringDataFromUniString( pUniStr, ImplStringLen( pUniStr ), + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +ByteString::ByteString( const sal_Unicode* pUniStr, xub_StrLen nLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pUniStr ); + + mpData = ImplGetStringDataFromUniString( pUniStr, nLen, + eTextEncoding, nCvtFlags ); +} + +// ======================================================================= + +static sal_uChar aImplByteTab[256] = +{ + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255 +}; + +// ======================================================================= + +struct Impl1ByteUnicodeTabData +{ + rtl_TextEncoding meTextEncoding; + sal_Unicode maUniTab[256]; + Impl1ByteUnicodeTabData* mpNext; +}; + +// ----------------------------------------------------------------------- + +struct Impl1ByteConvertTabData +{ + rtl_TextEncoding meSrcTextEncoding; + rtl_TextEncoding meDestTextEncoding; + sal_uChar maConvertTab[256]; + sal_uChar maRepConvertTab[256]; + Impl1ByteConvertTabData* mpNext; +}; + +// ======================================================================= + +sal_Unicode* ImplGet1ByteUnicodeTab( rtl_TextEncoding eTextEncoding ) +{ +#ifndef BOOTSTRAP + TOOLSINDATA* pToolsData = ImplGetToolsInData(); +#else + TOOLSINDATA* pToolsData = 0x0; +#endif + Impl1ByteUnicodeTabData* pTab = pToolsData->mpFirstUniTabData; + + while ( pTab ) + { + if ( pTab->meTextEncoding == eTextEncoding ) + return pTab->maUniTab; + pTab = pTab->mpNext; + } + + // get TextEncodingInfo + rtl_TextEncodingInfo aTextEncInfo; + aTextEncInfo.StructSize = sizeof( aTextEncInfo ); + rtl_getTextEncodingInfo( eTextEncoding, &aTextEncInfo ); + + if ( aTextEncInfo.MaximumCharSize == 1 ) + { + pTab = new Impl1ByteUnicodeTabData; + pTab->meTextEncoding = eTextEncoding; + pTab->mpNext = pToolsData->mpFirstUniTabData; + + rtl_TextToUnicodeConverter hConverter; + sal_uInt32 nInfo; + sal_Size nSrcBytes; + sal_Size nDestChars; + hConverter = rtl_createTextToUnicodeConverter( eTextEncoding ); + nDestChars = rtl_convertTextToUnicode( hConverter, 0, + (const sal_Char*)aImplByteTab, 256, + pTab->maUniTab, 256, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, + &nInfo, &nSrcBytes ); + rtl_destroyTextToUnicodeConverter( hConverter ); + + if ( (nSrcBytes != 256) || (nDestChars != 256) ) + delete pTab; + else + { + pToolsData->mpFirstUniTabData = pTab; + return pTab->maUniTab; + } + } + + return NULL; +} + +// ----------------------------------------------------------------------- + +static sal_uChar* ImplGet1ByteConvertTab( rtl_TextEncoding eSrcTextEncoding, + rtl_TextEncoding eDestTextEncoding, + BOOL bReplace ) +{ +#ifndef BOOTSTRAP + TOOLSINDATA* pToolsData = ImplGetToolsInData(); +#else + TOOLSINDATA* pToolsData = 0x0; +#endif + Impl1ByteConvertTabData* pTab = pToolsData->mpFirstConvertTabData; + + while ( pTab ) + { + if ( (pTab->meSrcTextEncoding == eSrcTextEncoding) && + (pTab->meDestTextEncoding == eDestTextEncoding) ) + { + if ( bReplace ) + return pTab->maRepConvertTab; + else + return pTab->maConvertTab; + } + pTab = pTab->mpNext; + } + + // get TextEncodingInfo + rtl_TextEncodingInfo aTextEncInfo1; + aTextEncInfo1.StructSize = sizeof( aTextEncInfo1 ); + rtl_getTextEncodingInfo( eSrcTextEncoding, &aTextEncInfo1 ); + rtl_TextEncodingInfo aTextEncInfo2; + aTextEncInfo2.StructSize = sizeof( aTextEncInfo2 ); + rtl_getTextEncodingInfo( eDestTextEncoding, &aTextEncInfo2 ); + + if ( (aTextEncInfo1.MaximumCharSize == 1) && + (aTextEncInfo2.MaximumCharSize == 1) ) + { + pTab = new Impl1ByteConvertTabData; + pTab->meSrcTextEncoding = eSrcTextEncoding; + pTab->meDestTextEncoding = eDestTextEncoding; + pTab->mpNext = pToolsData->mpFirstConvertTabData; + + rtl_TextToUnicodeConverter hConverter; + rtl_UnicodeToTextConverter hConverter2; + sal_uInt32 nInfo; + sal_Size nSrcBytes; + sal_Size nDestChars; + sal_Size nSrcChars; + sal_Size nDestBytes; + sal_Unicode aTempBuf[256]; + hConverter = rtl_createTextToUnicodeConverter( eSrcTextEncoding ); + nDestChars = rtl_convertTextToUnicode( hConverter, 0, + (const sal_Char*)aImplByteTab, 256, + aTempBuf, 256, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, + &nInfo, &nSrcBytes ); + rtl_destroyTextToUnicodeConverter( hConverter ); + if ( (nSrcBytes != 256) || (nDestChars != 256) ) + delete pTab; + else + { + hConverter2 = rtl_createUnicodeToTextConverter( eDestTextEncoding ); + nDestBytes = rtl_convertUnicodeToText( hConverter2, 0, + aTempBuf, 256, + (sal_Char*)pTab->maConvertTab, 256, + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 | + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT, + &nInfo, &nSrcChars ); + if ( (nDestBytes == 256) || (nSrcChars == 256) ) + { + nDestBytes = rtl_convertUnicodeToText( hConverter2, 0, + aTempBuf, 256, + (sal_Char*)pTab->maRepConvertTab, 256, + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE, + &nInfo, &nSrcChars ); + } + rtl_destroyUnicodeToTextConverter( hConverter2 ); + if ( (nDestBytes != 256) || (nSrcChars != 256) ) + delete pTab; + else + { + pToolsData->mpFirstConvertTabData = pTab; + if ( bReplace ) + return pTab->maRepConvertTab; + else + return pTab->maConvertTab; + } + } + } + + return NULL; +} + +// ======================================================================= + +void ImplDeleteCharTabData() +{ +#ifndef BOOTSTRAP + TOOLSINDATA* pToolsData = ImplGetToolsInData(); +#else + TOOLSINDATA* pToolsData = 0x0; +#endif + Impl1ByteUnicodeTabData* pTempUniTab; + Impl1ByteUnicodeTabData* pUniTab = pToolsData->mpFirstUniTabData; + while ( pUniTab ) + { + pTempUniTab = pUniTab->mpNext; + delete pUniTab; + pUniTab = pTempUniTab; + } + pToolsData->mpFirstUniTabData = NULL; + + Impl1ByteConvertTabData* pTempConvertTab; + Impl1ByteConvertTabData* pConvertTab = pToolsData->mpFirstConvertTabData; + while ( pConvertTab ) + { + pTempConvertTab = pConvertTab->mpNext; + delete pConvertTab; + pConvertTab = pTempConvertTab; + } + pToolsData->mpFirstConvertTabData = NULL; +} + +// ======================================================================= + +static void ImplStringConvert( ByteString* pString, + rtl_TextEncoding eSource, rtl_TextEncoding eTarget, + BOOL bReplace ) +{ + sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace ); + if ( pConvertTab ) + { + char* pStr = pString->mpData->maStr; + while ( *pStr ) + { + sal_uChar c = (sal_uChar)*pStr; + sal_uChar cConv = pConvertTab[c]; + if ( c != cConv ) + { + pStr = ImplCopyStringData( pString, pStr ); + *pStr = (char)cConv; + } + + pStr++; + } + } + else + { + rtl_UnicodeToTextConverter hSrcConverter = rtl_createTextToUnicodeConverter( eSource ); + sal_uInt32 nInfo; + sal_Size nSrcBytes; + sal_Size nDestChars; + sal_Size nTempLen; + sal_Unicode* pTempBuf; + nTempLen = pString->mpData->mnLen; + pTempBuf = new sal_Unicode[nTempLen]; + nDestChars = rtl_convertTextToUnicode( hSrcConverter, 0, + pString->mpData->maStr, pString->mpData->mnLen, + pTempBuf, nTempLen, + RTL_TEXTTOUNICODE_FLAGS_FLUSH | + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT, + &nInfo, &nSrcBytes ); + rtl_destroyTextToUnicodeConverter( hSrcConverter ); + // Hier werten wir bReplace nicht aus, da fuer MultiByte-Textencodings + // sowieso keine Ersatzdarstellung moeglich ist. Da sich der String + // sowieso in der Laenge aendern kann, nehmen wir auch sonst keine + // Ruecksicht darauf, das die Laenge erhalten bleibt. + ImplUpdateStringFromUniString( pString, pTempBuf, nDestChars, eTarget, + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE | + RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR | + RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 | + RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE | + RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE ); + delete pTempBuf; + } +} + +// ======================================================================= + +ByteString& ByteString::Convert( rtl_TextEncoding eSource, rtl_TextEncoding eTarget, BOOL bReplace ) +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + // rtl_TextEncoding Dontknow kann nicht konvertiert werden + if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) ) + return *this; + +#ifndef NOOLDSTRING + if ( eSource == CHARSET_SYSTEM ) + eSource = GetSystemCharSet(); + if ( eTarget == CHARSET_SYSTEM ) + eTarget = GetSystemCharSet(); +#endif + + // Wenn Source und Target gleich sind, muss nicht konvertiert werden + if ( eSource == eTarget ) + return *this; + + // rtl_TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten + // wollen wir die Zeichencodes beibehalten + if ( (eSource == RTL_TEXTENCODING_SYMBOL) && + (eTarget != RTL_TEXTENCODING_UTF7) && + (eTarget != RTL_TEXTENCODING_UTF8) ) + return *this; + if ( (eTarget == RTL_TEXTENCODING_SYMBOL) && + (eSource != RTL_TEXTENCODING_UTF7) && + (eSource != RTL_TEXTENCODING_UTF8) ) + return *this; + + // Zeichensatz umwandeln + ImplStringConvert( this, eSource, eTarget, bReplace ); + + return *this; +} + +// ======================================================================= + +char ByteString::Convert( char c, + rtl_TextEncoding eSource, rtl_TextEncoding eTarget, + BOOL bReplace ) +{ + // TextEncoding Dontknow kann nicht konvertiert werden + if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) ) + return '\0'; + +#ifndef NOOLDSTRING + if ( eSource == CHARSET_SYSTEM ) + eSource = GetSystemCharSet(); + if ( eTarget == CHARSET_SYSTEM ) + eTarget = GetSystemCharSet(); +#endif + + // Wenn Source und Target gleich sind, muss nicht konvertiert werden + if ( eSource == eTarget ) + return c; + + // TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten + // wollen wir die Zeichencodes beibehalten + if ( (eSource == RTL_TEXTENCODING_SYMBOL) && + (eTarget != RTL_TEXTENCODING_UTF7) && + (eTarget != RTL_TEXTENCODING_UTF8) ) + return '\0'; + if ( (eTarget == RTL_TEXTENCODING_SYMBOL) && + (eSource != RTL_TEXTENCODING_UTF7) && + (eSource != RTL_TEXTENCODING_UTF8) ) + return '\0'; + + sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace ); + if ( pConvertTab ) + return (char)pConvertTab[(sal_uChar)c]; + else + return '\0'; +} + +// ======================================================================= + +sal_Unicode ByteString::ConvertToUnicode( char c, rtl_TextEncoding eTextEncoding ) +{ + sal_Size nLen = 1; + return ConvertToUnicode( &c, &nLen, eTextEncoding ); +} + +// ----------------------------------------------------------------------- + +char ByteString::ConvertFromUnicode( sal_Unicode c, rtl_TextEncoding eTextEncoding, BOOL bReplace ) +{ + sal_Size nLen; + char aBuf[30]; + nLen = ConvertFromUnicode( c, aBuf, sizeof( aBuf ), eTextEncoding, bReplace ); + if ( nLen == 1 ) + return aBuf[0]; + else + return 0; +} + +// ----------------------------------------------------------------------- + +sal_Unicode ByteString::ConvertToUnicode( const char* pChar, sal_Size* pLen, rtl_TextEncoding eTextEncoding ) +{ + // TextEncoding Dontknow wird nicht konvertiert + if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW ) + return 0; +#ifndef NOOLDSTRING + else if ( eTextEncoding == CHARSET_SYSTEM ) + eTextEncoding = GetSystemCharSet(); +#endif + + rtl_TextToUnicodeConverter hConverter; + sal_uInt32 nInfo; + sal_Size nSrcBytes; + sal_Size nDestChars; + sal_Unicode nConvChar; + hConverter = rtl_createTextToUnicodeConverter( eTextEncoding ); + nDestChars = rtl_convertTextToUnicode( hConverter, 0, + (const sal_Char*)pChar, *pLen, + &nConvChar, 1, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_FLUSH, + &nInfo, &nSrcBytes ); + rtl_destroyTextToUnicodeConverter( hConverter ); + + if ( nDestChars == 1 ) + { + *pLen = nSrcBytes; + return nConvChar; + } + else + { + *pLen = 0; + return 0; + } +} + +// ----------------------------------------------------------------------- + +sal_Size ByteString::ConvertFromUnicode( sal_Unicode c, char* pBuf, sal_Size nBufLen, rtl_TextEncoding eTextEncoding, + BOOL bReplace ) +{ + // TextEncoding Dontknow wird nicht konvertiert + if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW ) + return '\0'; +#ifndef NOOLDSTRING + else if ( eTextEncoding == CHARSET_SYSTEM ) + eTextEncoding = GetSystemCharSet(); +#endif + + rtl_UnicodeToTextConverter hConverter; + sal_uInt32 nInfo; + sal_Size nSrcChars; + sal_Size nDestBytes; + sal_Unicode cUni = c; + sal_uInt32 nFlags = RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE | + RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE | + RTL_UNICODETOTEXT_FLAGS_FLUSH; + if ( bReplace ) + { + nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT | + RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT; + nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE; + if ( nBufLen > 1 ) + nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR; + } + else + { + nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 | + RTL_UNICODETOTEXT_FLAGS_INVALID_0; + } + + hConverter = rtl_createUnicodeToTextConverter( eTextEncoding ); + nDestBytes = rtl_convertUnicodeToText( hConverter, 0, + &cUni, 1, + (sal_Char*)pBuf, nBufLen, + nFlags, + &nInfo, &nSrcChars ); + rtl_destroyUnicodeToTextConverter( hConverter ); + return nDestBytes; +} + +// ======================================================================= + +ByteString::ByteString( const NAMESPACE_RTL(OString)& rStr ) +{ + DBG_CTOR( ByteString, DbgCheckByteString ); + + mpData = (ByteStringData*)rStr.pData; + ImplIncRefCount( mpData ); +} + +// ----------------------------------------------------------------------- + +NAMESPACE_RTL(OString)::OString( const ByteString& rStr ) +{ + pData = (rtl_String*)rStr.mpData; + rtl_string_acquire( pData ); +} + +// ----------------------------------------------------------------------- + +ByteString& ByteString::Assign( const NAMESPACE_RTL(OString)& rStr ) +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + rtl_string_acquire( rStr.pData ); + ImplDeleteData( mpData ); + mpData = (ByteStringData*)rStr.pData; + return *this; +} diff --git a/tools/source/string/strimp.cxx b/tools/source/string/strimp.cxx new file mode 100644 index 000000000000..0b667f14e6c4 --- /dev/null +++ b/tools/source/string/strimp.cxx @@ -0,0 +1,2306 @@ +/************************************************************************* + * + * $RCSfile: strimp.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +// ======================================================================= + +// Daten des Strings fuer einen NULL-String +static STRINGDATA aImplEmptyStrData = { 1, 0, 0 }; + +// ======================================================================= + +static sal_Int32 ImplStringCompare( const STRCODE* pStr1, const STRCODE* pStr2 ) +{ + sal_Int32 nRet; +#if STRCODE == sal_Unicode + while ( ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)*pStr2)) == 0) && + *pStr2 ) +#else + while ( ((nRet = ((sal_Int32)((unsigned STRCODE)*pStr1))-((sal_Int32)((unsigned STRCODE)*pStr2))) == 0) && + *pStr2 ) +#endif + { + pStr1++; + pStr2++; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringCompare( const STRCODE* pStr1, const STRCODE* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; +#if STRCODE == sal_Unicode + while ( nCount && + ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)*pStr2)) == 0) && + *pStr2 ) +#else + while ( nCount && + ((nRet = ((sal_Int32)((unsigned STRCODE)*pStr1))-((sal_Int32)((unsigned STRCODE)*pStr2))) == 0) && + *pStr2 ) +#endif + { + pStr1++; + pStr2++; + nCount--; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringCompareWithoutZero( const STRCODE* pStr1, const STRCODE* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; +#if STRCODE == sal_Unicode + while ( nCount && + ((nRet = ((sal_Int32)*pStr1)-((sal_Int32)*pStr2)) == 0) ) +#else + while ( nCount && + ((nRet = ((sal_Int32)((unsigned STRCODE)*pStr1))-((sal_Int32)((unsigned STRCODE)*pStr2))) == 0) ) +#endif + { + pStr1++; + pStr2++; + nCount--; + } + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringICompare( const STRCODE* pStr1, const STRCODE* pStr2 ) +{ + sal_Int32 nRet; + STRCODE c1; + STRCODE c2; + do + { + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + c1 = *pStr1; + c2 = *pStr2; + if ( (c1 >= 65) && (c1 <= 90) ) + c1 += 32; + if ( (c2 >= 65) && (c2 <= 90) ) + c2 += 32; +#if STRCODE == sal_Unicode + nRet = ((sal_Int32)c1)-((sal_Int32)c2); +#else + nRet = ((sal_Int32)((unsigned STRCODE)c1))-((sal_Int32)((unsigned STRCODE)c2)); +#endif + if ( nRet != 0 ) + break; + + pStr1++; + pStr2++; + } + while ( c2 ); + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringICompare( const STRCODE* pStr1, const STRCODE* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; + STRCODE c1; + STRCODE c2; + do + { + if ( !nCount ) + break; + + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + c1 = *pStr1; + c2 = *pStr2; + if ( (c1 >= 65) && (c1 <= 90) ) + c1 += 32; + if ( (c2 >= 65) && (c2 <= 90) ) + c2 += 32; +#if STRCODE == sal_Unicode + nRet = ((sal_Int32)c1)-((sal_Int32)c2); +#else + nRet = ((sal_Int32)((unsigned STRCODE)c1))-((sal_Int32)((unsigned STRCODE)c2)); +#endif + if ( nRet != 0 ) + break; + + pStr1++; + pStr2++; + nCount--; + } + while ( c2 ); + + return nRet; +} + +// ----------------------------------------------------------------------- + +static sal_Int32 ImplStringICompareWithoutZero( const STRCODE* pStr1, const STRCODE* pStr2, + xub_StrLen nCount ) +{ + sal_Int32 nRet = 0; + STRCODE c1; + STRCODE c2; + do + { + if ( !nCount ) + break; + + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + c1 = *pStr1; + c2 = *pStr2; + if ( (c1 >= 65) && (c1 <= 90) ) + c1 += 32; + if ( (c2 >= 65) && (c2 <= 90) ) + c2 += 32; +#if STRCODE == sal_Unicode + nRet = ((sal_Int32)c1)-((sal_Int32)c2); +#else + nRet = ((sal_Int32)((unsigned STRCODE)c1))-((sal_Int32)((unsigned STRCODE)c2)); +#endif + + pStr1++; + pStr2++; + nCount--; + } + while ( nRet == 0 ); + + return nRet; +} + +// ======================================================================= + +#ifdef DBG_UTIL +const char* DBGCHECKSTRING( const void* pString ) +{ + STRING* p = (STRING*)pString; + + if ( p->mpData->maStr[p->mpData->mnLen] != 0 ) + return "String damaged: aStr[nLen] != 0"; + + return NULL; +} +#endif + +// ======================================================================= + +static STRINGDATA* ImplAllocData( xub_StrLen nLen ) +{ + // Dann kopiere die Daten + STRINGDATA* pData = (STRINGDATA*)rtl_allocateMemory( sizeof(STRINGDATA)+(nLen*sizeof( STRCODE )) ); + pData->mnRefCount = 1; + pData->mnLen = nLen; + pData->maStr[nLen] = 0; + return pData; +} + +// ----------------------------------------------------------------------- + +static void _ImplDeleteData( STRINGDATA* pStrData ) +{ + // alle referenzierten Strings koennen zur gleichen Zeit geloescht + // wurden sein, somit muss hier noch geprueft werden, ob ich + // der letzte gleichzeitig zerstoerte String bin + if ( !osl_decrementInterlockedCount(&pStrData->mnRefCount) ) + { + DBG_ASSERT( aImplEmptyStrData.mnRefCount != 0, "String::ImplIncRefCount() - EmptyStr RefCount == 0" ); + rtl_freeMemory( pStrData ); + } +} + +// ----------------------------------------------------------------------- + +inline void ImplDeleteData( STRINGDATA* pStrData ) +{ + DBG_ASSERT( aImplEmptyStrData.mnRefCount != 0, "String::ImplIncRefCount() - EmptyStr RefCount == 0" ); + + // Ist der ReferenzCounter groesser 0 + if ( pStrData->mnRefCount == 1 ) + rtl_freeMemory( pStrData ); + else + _ImplDeleteData( pStrData ); +} + +// ----------------------------------------------------------------------- + +static STRINGDATA* _ImplCopyData( STRINGDATA* pData ) +{ + xub_StrLen nSize = sizeof(STRINGDATA)+(pData->mnLen*sizeof( STRCODE )); + STRINGDATA* pNewData = (STRINGDATA*)rtl_allocateMemory( nSize ); + memcpy( pNewData, pData, nSize ); + pNewData->mnRefCount = 1; + _ImplDeleteData( pData ); + return pNewData; +} + +// ----------------------------------------------------------------------- + +inline void ImplCopyData( STRING* pString ) +{ + DBG_ASSERT( (pString->mpData->mnRefCount > 0), "String::ImplCopyData() - RefCount == 0" ); + DBG_ASSERT( aImplEmptyStrData.mnRefCount != 0, "String::ImplIncRefCount() - EmptyStr RefCount == 0" ); + + // ist es ein referenzierter String, dann die Daten abkoppeln + if ( pString->mpData->mnRefCount != 1 ) + pString->mpData = _ImplCopyData( pString->mpData ); +} + +// ----------------------------------------------------------------------- + +static STRCODE* _ImplCopyStringData( STRING* pString, STRCODE* pStr ) +{ + DBG_ASSERT( (pStr >= pString->mpData->maStr) && + ((pStr-pString->mpData->maStr) < pString->mpData->mnLen), + "ImplCopyStringData - pStr from other String-Instanz" ); + + unsigned int nIndex = (unsigned int)(pStr-pString->mpData->maStr); + pString->mpData = _ImplCopyData( pString->mpData ); + pStr = pString->mpData->maStr + nIndex; + return pStr; +} + +// ----------------------------------------------------------------------- + +inline STRCODE* ImplCopyStringData( STRING* pString, STRCODE* pStr ) +{ + // Ist der Referenzzaehler groesser 0 + if ( pString->mpData->mnRefCount != 1 ) + pStr = _ImplCopyStringData( pString, pStr ); + return pStr; +} + +// ----------------------------------------------------------------------- + +inline void ImplIncRefCount( STRINGDATA* pData ) +{ + osl_incrementInterlockedCount( &pData->mnRefCount ); +} + +// ----------------------------------------------------------------------- + +inline xub_StrLen ImplGetCopyLen( xub_StrLen nStrLen, xub_StrLen nCopyLen ) +{ + if ( (ULONG)nStrLen+nCopyLen > STRING_MAXLEN ) + nCopyLen = STRING_MAXLEN-nStrLen; + return nCopyLen; +} + +// ======================================================================= + +STRING::STRING() +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + + // Leerer String + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; +} + +// ----------------------------------------------------------------------- + +STRING::STRING( const STRING& rStr ) +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Pointer auf die Daten des uebergebenen Strings setzen und + // Referenzzaehler erhoehen + ImplIncRefCount( rStr.mpData ); + mpData = rStr.mpData; +} + +// ----------------------------------------------------------------------- + +STRING::STRING( const STRING& rStr, xub_StrLen nPos, xub_StrLen nLen ) +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Stringlaenge ermitteln + if ( nPos > rStr.mpData->mnLen ) + nLen = 0; + else + { + // Laenge korrigieren, wenn noetig + xub_StrLen nMaxLen = rStr.mpData->mnLen-nPos; + if ( nLen > nMaxLen ) + nLen = nMaxLen; + } + + // Ist es kein leerer String + if ( nLen ) + { + // Reicht ein einfaches erhoehen des Referenzcounters + if ( (nPos == 0) && (nLen == rStr.mpData->mnLen) ) + { + ImplIncRefCount( rStr.mpData ); + mpData = rStr.mpData; + } + else + { + // Verwaltungsdaten anlegen und String kopieren + mpData = ImplAllocData( nLen ); + memcpy( mpData->maStr, rStr.mpData->maStr+nPos, nLen*sizeof( STRCODE ) ); + } + } + else + { + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } +} + +// ----------------------------------------------------------------------- + +STRING::STRING( const STRCODE* pCharStr ) +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + + // Stringlaenge ermitteln + // Bei diesem Ctor darf NULL uebergeben werden + xub_StrLen nLen; + if ( pCharStr ) + nLen = ImplStringLen( pCharStr ); + else + nLen = 0; + + // Ist es kein leerer String + if ( nLen ) + { + if ( nLen > STRING_MAXLEN ) + nLen = STRING_MAXLEN; + + // Verwaltungsdaten anlegen und String kopieren + mpData = ImplAllocData( nLen ); + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + } + else + { + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } +} + +// ----------------------------------------------------------------------- + +STRING::STRING( const STRCODE* pCharStr, xub_StrLen nLen ) +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::String() - pCharStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pCharStr ); + +#ifdef DBG_UTIL + if ( DbgIsAssert() ) + { + for ( xub_StrLen i = 0; i < nLen; i++ ) + { + if ( !pCharStr[i] ) + { + DBG_ERROR( "String::String() : nLen is wrong" ); + } + } + } +#endif + + // Ist es kein leerer String + if ( nLen ) + { + if ( nLen > STRING_MAXLEN ) + nLen = STRING_MAXLEN; + + // Verwaltungsdaten anlegen und String kopieren + mpData = ImplAllocData( nLen ); + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + } + else + { + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } +} + +// ----------------------------------------------------------------------- + +STRING::STRING( STRCODE c ) +{ + DBG_CTOR( STRING, DBGCHECKSTRING ); + DBG_ASSERT( c, "String::String() - c is 0" ); + + // Verwaltungsdaten anlegen und initialisieren + mpData = ImplAllocData( 1 ); + mpData->maStr[0] = c; +} + +// ----------------------------------------------------------------------- + +STRING::~STRING() +{ + DBG_DTOR( STRING, DBGCHECKSTRING ); + + // Daten loeschen + ImplDeleteData( mpData ); +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Assign( const STRING& rStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + ImplIncRefCount( rStr.mpData ); + ImplDeleteData( mpData ); + mpData = rStr.mpData; + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Assign( const STRCODE* pCharStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::Assign() - pCharStr is NULL" ); + + // Stringlaenge ermitteln +#ifdef NOOLDSTRING + xub_StrLen nLen = ImplStringLen( pCharStr ); +#else + xub_StrLen nLen; + if ( pCharStr ) + nLen = ImplStringLen( pCharStr ); + else + nLen = 0; +#endif + + if ( !nLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + else + { + // Wenn String genauso lang ist, wie der String, dann direkt kopieren + if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) ) + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + else + { + // Alte Daten loeschen + ImplDeleteData( mpData ); + + // Daten initialisieren und String kopieren + mpData = ImplAllocData( nLen ); + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Assign( const STRCODE* pCharStr, xub_StrLen nLen ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::Assign() - pCharStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pCharStr ); + +#ifdef DBG_UTIL + if ( DbgIsAssert() ) + { + for ( xub_StrLen i = 0; i < nLen; i++ ) + { + if ( !pCharStr[i] ) + { + DBG_ERROR( "String::Assign() : nLen is wrong" ); + } + } + } +#endif + + if ( !nLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + else + { + // Wenn String genauso lang ist, wie der String, dann direkt kopieren + if ( (nLen == mpData->mnLen) && (mpData->mnRefCount == 1) ) + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + else + { + // Alte Daten loeschen + ImplDeleteData( mpData ); + + // Daten initialisieren und String kopieren + mpData = ImplAllocData( nLen ); + memcpy( mpData->maStr, pCharStr, nLen*sizeof( STRCODE ) ); + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Assign( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( c, "String::Assign() - c is 0" ); + + // Verwaltungsdaten anlegen und initialisieren + ImplDeleteData( mpData ); + mpData = ImplAllocData( 1 ); + mpData->maStr[0] = c; + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Append( const STRING& rStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Wenn String leer, dann reicht eine Zuweisung + xub_StrLen nLen = mpData->mnLen; + if ( !nLen ) + { + ImplIncRefCount( rStr.mpData ); + ImplDeleteData( mpData ); + mpData = rStr.mpData; + } + else + { + // Ueberlauf abfangen + xub_StrLen nCopyLen = ImplGetCopyLen( nLen, rStr.mpData->mnLen ); + + // Ist der uebergebene String kein Leerstring + if ( nCopyLen ) + { + // Neue Datenstruktur und neuen String erzeugen + STRINGDATA* pNewData = ImplAllocData( nLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nLen, rStr.mpData->maStr, nCopyLen*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Append( const STRCODE* pCharStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::Append() - pCharStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nLen = mpData->mnLen; +#ifdef NOOLDSTRING + xub_StrLen nCopyLen = ImplStringLen( pCharStr ); +#else + xub_StrLen nCopyLen; + if ( pCharStr ) + nCopyLen = ImplStringLen( pCharStr ); + else + nCopyLen = 0; +#endif + + // Ueberlauf abfangen + nCopyLen = ImplGetCopyLen( nLen, nCopyLen ); + + // Ist es kein leerer String + if ( nCopyLen ) + { + // Neue Datenstruktur und neuen String erzeugen + STRINGDATA* pNewData = ImplAllocData( nLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nLen, pCharStr, nCopyLen*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Append( const STRCODE* pCharStr, xub_StrLen nCharLen ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::Append() - pCharStr is NULL" ); + + if ( nCharLen == STRING_LEN ) + nCharLen = ImplStringLen( pCharStr ); + +#ifdef DBG_UTIL + if ( DbgIsAssert() ) + { + for ( xub_StrLen i = 0; i < nCharLen; i++ ) + { + if ( !pCharStr[i] ) + { + DBG_ERROR( "String::Append() : nLen is wrong" ); + } + } + } +#endif + + // Ueberlauf abfangen + xub_StrLen nLen = mpData->mnLen; + xub_StrLen nCopyLen = ImplGetCopyLen( nLen, nCharLen ); + + // Ist es kein leerer String + if ( nCopyLen ) + { + // Neue Datenstruktur und neuen String erzeugen + STRINGDATA* pNewData = ImplAllocData( nLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nLen, pCharStr, nCopyLen*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Append( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // kein 0-Character und maximale Stringlaenge nicht ueberschreiten + xub_StrLen nLen = mpData->mnLen; + if ( c && (nLen < STRING_MAXLEN) ) + { + // Neue Datenstruktur und neuen String erzeugen + STRINGDATA* pNewData = ImplAllocData( nLen+1 ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + pNewData->maStr[nLen] = c; + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +void STRING::SetChar( xub_StrLen nIndex, STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( nIndex < mpData->mnLen, "String::SetChar() - nIndex > String.Len()" ); + + // Daten kopieren, wenn noetig und Character zuweisen + ImplCopyData( this ); + mpData->maStr[nIndex] = c; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Insert( const STRING& rStr, xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Ueberlauf abfangen + xub_StrLen nCopyLen = ImplGetCopyLen( mpData->mnLen, rStr.mpData->mnLen ); + + // Ist der einzufuegende String ein Leerstring + if ( !nCopyLen ) + return *this; + + // Index groesser als Laenge + if ( nIndex > mpData->mnLen ) + nIndex = mpData->mnLen; + + // Neue Laenge ermitteln und neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex, rStr.mpData->maStr, nCopyLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex+nCopyLen, mpData->maStr+nIndex, + (mpData->mnLen-nIndex)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Insert( const STRING& rStr, xub_StrLen nPos, xub_StrLen nLen, + xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Stringlaenge ermitteln + if ( nPos > rStr.mpData->mnLen ) + nLen = 0; + else + { + // Laenge korrigieren, wenn noetig + xub_StrLen nMaxLen = rStr.mpData->mnLen-nPos; + if ( nLen > nMaxLen ) + nLen = nMaxLen; + } + + // Ueberlauf abfangen + xub_StrLen nCopyLen = ImplGetCopyLen( mpData->mnLen, nLen ); + + // Ist der einzufuegende String ein Leerstring + if ( !nCopyLen ) + return *this; + + // Index groesser als Laenge + if ( nIndex > mpData->mnLen ) + nIndex = mpData->mnLen; + + // Neue Laenge ermitteln und neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex, rStr.mpData->maStr+nPos, nCopyLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex+nCopyLen, mpData->maStr+nIndex, + (mpData->mnLen-nIndex)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Insert( const STRCODE* pCharStr, xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_ASSERT( pCharStr, "String::Insert() - pCharStr is NULL" ); + + // Stringlaenge ermitteln + xub_StrLen nCopyLen = ImplStringLen( pCharStr ); + + // Ueberlauf abfangen + nCopyLen = ImplGetCopyLen( mpData->mnLen, nCopyLen ); + + // Ist der einzufuegende String ein Leerstring + if ( !nCopyLen ) + return *this; + + // Index groesser als Laenge + if ( nIndex > mpData->mnLen ) + nIndex = mpData->mnLen; + + // Neue Laenge ermitteln und neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen+nCopyLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex, pCharStr, nCopyLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex+nCopyLen, mpData->maStr+nIndex, + (mpData->mnLen-nIndex)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Insert( STRCODE c, xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Ist es kein 0-Character + if ( !c || (mpData->mnLen == STRING_MAXLEN) ) + return *this; + + // Index groesser als Laenge + if ( nIndex > mpData->mnLen ) + nIndex = mpData->mnLen; + + // Neue Laenge ermitteln und neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen+1 ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + pNewData->maStr[nIndex] = c; + memcpy( pNewData->maStr+nIndex+1, mpData->maStr+nIndex, + (mpData->mnLen-nIndex)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Replace( xub_StrLen nIndex, xub_StrLen nCount, const STRING& rStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Wenn Index groessergleich Laenge ist, dann ist es ein Append + if ( nIndex >= mpData->mnLen ) + { + Append( rStr ); + return *this; + } + + // Ist es eine Zuweisung + if ( (nIndex == 0) && (nCount >= mpData->mnLen) ) + { + Assign( rStr ); + return *this; + } + + // Reicht ein Erase + xub_StrLen nStrLen = rStr.mpData->mnLen; + if ( !nStrLen ) + return Erase( nIndex, nCount ); + + // nCount darf nicht ueber das Stringende hinnausgehen + if ( (ULONG)nIndex+nCount > mpData->mnLen ) + nCount = mpData->mnLen-nIndex; + + // Reicht ein Insert + if ( !nCount ) + return Insert( rStr, nIndex ); + + // Reicht eine zeichenweise Zuweisung + if ( nCount == nStrLen ) + { + ImplCopyData( this ); + memcpy( mpData->maStr+nIndex, rStr.mpData->maStr, nCount*sizeof( STRCODE ) ); + return *this; + } + + // Ueberlauf abfangen + nStrLen = ImplGetCopyLen( mpData->mnLen-nCount, nStrLen ); + + // Neue Daten anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen-nCount+nStrLen ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex, rStr.mpData->maStr, nStrLen*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex+nStrLen, mpData->maStr+nIndex+nCount, + (mpData->mnLen-nIndex-nCount+1)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Erase( xub_StrLen nIndex, xub_StrLen nCount ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Ist der Index ausserhalb des Strings oder ist nCount == 0 + if ( (nIndex > mpData->mnLen) || !nCount ) + return *this; + + // nCount darf nicht ueber das Stringende hinnausgehen + if ( (ULONG)nIndex+nCount > mpData->mnLen ) + nCount = mpData->mnLen-nIndex; + + // Ist das Ergebnis kein Leerstring + if ( mpData->mnLen - nCount ) + { + // Neue Daten anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen-nCount ); + + // String kopieren + memcpy( pNewData->maStr, mpData->maStr, nIndex*sizeof( STRCODE ) ); + memcpy( pNewData->maStr+nIndex, mpData->maStr+nIndex+nCount, + (mpData->mnLen-nIndex-nCount+1)*sizeof( STRCODE ) ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + else + { + // Leerer String + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Fill( xub_StrLen nCount, STRCODE cFillChar ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + if ( !nCount ) + return *this; + + // Ist nCount groesser wie der jetzige String, dann verlaengern + if ( nCount > mpData->mnLen ) + { + // Auf max. Laenge beschraenken + if ( nCount > STRING_MAXLEN ) + nCount = STRING_MAXLEN; + + // dann neuen String mit der neuen Laenge anlegen + STRINGDATA* pNewData = ImplAllocData( nCount ); + ImplDeleteData( mpData ); + mpData = pNewData; + } + else + ImplCopyData( this ); + + STRCODE* pStr = mpData->maStr; + do + { + *pStr = cFillChar; + pStr++; + nCount--; + } + while ( nCount ); + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Expand( xub_StrLen nCount, STRCODE cExpandChar ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Muss der String erweitert werden + xub_StrLen nLen = mpData->mnLen; + if ( nCount <= nLen ) + return *this; + + // Neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( nCount ); + + // Alten String kopieren + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + + // und initialisieren + STRCODE* pStr = pNewData->maStr; + pStr += nLen; + nCount -= nLen; + do + { + *pStr = cExpandChar; + pStr++; + nCount--; + } + while ( nCount ); + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::EraseLeadingChars( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + if ( mpData->maStr[0] != c ) + return *this; + + xub_StrLen nStart = 0; + while ( mpData->maStr[nStart] == c ) + nStart++; + + return Erase( 0, nStart ); +} + +// ----------------------------------------------------------------------- + +STRING& STRING::EraseTrailingChars( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nEnd = mpData->mnLen; + while ( nEnd && (mpData->maStr[nEnd-1] == c) ) + nEnd--; + + if ( nEnd != mpData->mnLen ) + Erase( nEnd ); + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::EraseLeadingAndTrailingChars( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nStart = 0; + while ( mpData->maStr[nStart] == c ) + nStart++; + if ( nStart ) + Erase( 0, nStart ); + + xub_StrLen nEnd = mpData->mnLen; + while ( nEnd && (mpData->maStr[nEnd-1] == c) ) + nEnd--; + if ( nEnd != mpData->mnLen ) + Erase( nEnd ); + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::EraseAllChars( STRCODE c ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nCount = 0; + xub_StrLen i = 0; + while ( i < mpData->mnLen ) + { + if ( mpData->maStr[i] == c ) + nCount++; + i++; + } + + if ( nCount ) + { + if ( nCount == mpData->mnLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + else + { + // Neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( mpData->mnLen-nCount ); + + // Alten String kopieren und initialisieren + nCount = 0; + for( xub_StrLen i = 0; i < mpData->mnLen; i++ ) + { + if ( mpData->maStr[i] != c ) + { + pNewData->maStr[nCount] = mpData->maStr[i]; + nCount++; + } + } + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::Reverse() +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + if ( !mpData->mnLen ) + return *this; + + // Daten kopieren, wenn noetig + ImplCopyData( this ); + + // Reverse + STRCODE cTemp; + xub_StrLen nCount = mpData->mnLen / 2; + for ( xub_StrLen i = 0; i < nCount; i++ ) + { + cTemp = mpData->maStr[i]; + mpData->maStr[i] = mpData->maStr[mpData->mnLen-i-1]; + mpData->maStr[mpData->mnLen-i-1] = cTemp; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::ToLowerAscii() +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + STRCODE* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + // Ist das Zeichen zwischen 'A' und 'Z' dann umwandeln + if ( (*pStr >= 65) && (*pStr <= 90) ) + { + // Daten kopieren, wenn noetig + pStr = ImplCopyStringData( this, pStr ); + *pStr += 32; + } + + pStr++; + nIndex++; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::ToUpperAscii() +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + STRCODE* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + // Ist das Zeichen zwischen 'a' und 'z' dann umwandeln + if ( (*pStr >= 97) && (*pStr <= 122) ) + { + // Daten kopieren, wenn noetig + pStr = ImplCopyStringData( this, pStr ); + *pStr -= 32; + } + + pStr++; + nIndex++; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +STRING& STRING::ConvertLineEnd( LineEnd eLineEnd ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Zeilenumbrueche ermitteln und neue Laenge berechnen + BOOL bConvert = FALSE; // Muss konvertiert werden + const STRCODE* pStr = mpData->maStr; // damit es schneller geht + xub_StrLen nLineEndLen = (eLineEnd == LINEEND_CRLF) ? 2 : 1; + xub_StrLen nLen = 0; // Ziel-Laenge + xub_StrLen i = 0; // Source-Zaehler + + while ( i < mpData->mnLen ) + { + // Bei \r oder \n gibt es neuen Zeilenumbruch + if ( (pStr[i] == _CR) || (pStr[i] == _LF) ) + { + nLen += nLineEndLen; + + // Wenn schon gesetzt, dann brauchen wir keine aufwendige Abfrage + if ( !bConvert ) + { + // Muessen wir Konvertieren + if ( ((eLineEnd != LINEEND_LF) && (pStr[i] == _LF)) || + ((eLineEnd == LINEEND_CRLF) && (pStr[i+1] != _LF)) || + ((eLineEnd == LINEEND_LF) && + ((pStr[i] == _CR) || (pStr[i+1] == _CR))) || + ((eLineEnd == LINEEND_CR) && + ((pStr[i] == _LF) || (pStr[i+1] == _LF))) ) + bConvert = TRUE; + } + + // \r\n oder \n\r, dann Zeichen ueberspringen + if ( ((pStr[i+1] == _CR) || (pStr[i+1] == _LF)) && + (pStr[i] != pStr[i+1]) ) + i++; + } + else + nLen++; + i++; + + // Wenn String zu lang, dann konvertieren wir nicht + if ( nLen >= STRING_MAXLEN ) + return *this; + } + + // Zeilenumbrueche konvertieren + if ( bConvert ) + { + // Neuen String anlegen + STRINGDATA* pNewData = ImplAllocData( nLen ); + xub_StrLen j = 0; + i = 0; + while ( i < mpData->mnLen ) + { + // Bei \r oder \n gibt es neuen Zeilenumbruch + if ( (pStr[i] == _CR) || (pStr[i] == _LF) ) + { + if ( eLineEnd == LINEEND_CRLF ) + { + pNewData->maStr[j] = _CR; + pNewData->maStr[j+1] = _LF; + j += 2; + } + else + { + if ( eLineEnd == LINEEND_CR ) + pNewData->maStr[j] = _CR; + else + pNewData->maStr[j] = _LF; + j++; + } + + if ( ((pStr[i+1] == _CR) || (pStr[i+1] == _LF)) && + (pStr[i] != pStr[i+1]) ) + i++; + } + else + { + pNewData->maStr[j] = mpData->maStr[i]; + j++; + } + + i++; + } + + // Alte Daten loeschen und Neue zuweisen + ImplDeleteData( mpData ); + mpData = pNewData; + } + + return *this; +} + +// ----------------------------------------------------------------------- + +StringCompare STRING::CompareTo( const STRING& rStr, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Auf Gleichheit der Pointer testen + if ( mpData == rStr.mpData ) + return COMPARE_EQUAL; + + // Maximale Laenge ermitteln + if ( mpData->mnLen < nLen ) + nLen = mpData->mnLen+1; + if ( rStr.mpData->mnLen < nLen ) + nLen = rStr.mpData->mnLen+1; + + // String vergleichen + sal_Int32 nCompare = ImplStringCompareWithoutZero( mpData->maStr, rStr.mpData->maStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +StringCompare STRING::CompareTo( const STRCODE* pCharStr, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // String vergleichen + sal_Int32 nCompare = ImplStringCompare( mpData->maStr, pCharStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +StringCompare STRING::CompareIgnoreCaseToAscii( const STRING& rStr, + xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Auf Gleichheit der Pointer testen + if ( mpData == rStr.mpData ) + return COMPARE_EQUAL; + + // Maximale Laenge ermitteln + if ( mpData->mnLen < nLen ) + nLen = mpData->mnLen+1; + if ( rStr.mpData->mnLen < nLen ) + nLen = rStr.mpData->mnLen+1; + + // String vergleichen + sal_Int32 nCompare = ImplStringICompareWithoutZero( mpData->maStr, rStr.mpData->maStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +StringCompare STRING::CompareIgnoreCaseToAscii( const STRCODE* pCharStr, + xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // String vergleichen + sal_Int32 nCompare = ImplStringICompare( mpData->maStr, pCharStr, nLen ); + + // Rueckgabewert anpassen + if ( nCompare == 0 ) + return COMPARE_EQUAL; + else if ( nCompare < 0 ) + return COMPARE_LESS; + else + return COMPARE_GREATER; +} + +// ----------------------------------------------------------------------- + +BOOL STRING::Equals( const STRING& rStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Sind die Daten gleich + if ( mpData == rStr.mpData ) + return TRUE; + + // Gleiche Laenge + if ( mpData->mnLen != rStr.mpData->mnLen ) + return FALSE; + + // String vergleichen + return (ImplStringCompareWithoutZero( mpData->maStr, rStr.mpData->maStr, mpData->mnLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::Equals( const STRCODE* pCharStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + return (ImplStringCompare( mpData->maStr, pCharStr ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::EqualsIgnoreCaseAscii( const STRING& rStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Sind die Daten gleich + if ( mpData == rStr.mpData ) + return TRUE; + + // Gleiche Laenge + if ( mpData->mnLen != rStr.mpData->mnLen ) + return FALSE; + + // String vergleichen + return (ImplStringICompareWithoutZero( mpData->maStr, rStr.mpData->maStr, mpData->mnLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::EqualsIgnoreCaseAscii( const STRCODE* pCharStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + return (ImplStringICompare( mpData->maStr, pCharStr ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::Equals( const STRING& rStr, xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (rStr.mpData->mnLen == 0); + xub_StrLen nMaxLen = mpData->mnLen-nIndex; + if ( nMaxLen < nLen ) + { + if ( rStr.mpData->mnLen != nMaxLen ) + return FALSE; + nLen = nMaxLen; + } + + // String vergleichen + return (ImplStringCompareWithoutZero( mpData->maStr+nIndex, rStr.mpData->maStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::Equals( const STRCODE* pCharStr, xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (*pCharStr == 0); + + return (ImplStringCompare( mpData->maStr+nIndex, pCharStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::EqualsIgnoreCaseAscii( const STRING& rStr, xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (rStr.mpData->mnLen == 0); + xub_StrLen nMaxLen = mpData->mnLen-nIndex; + if ( nMaxLen < nLen ) + { + if ( rStr.mpData->mnLen != nMaxLen ) + return FALSE; + nLen = nMaxLen; + } + + // String vergleichen + return (ImplStringICompareWithoutZero( mpData->maStr+nIndex, rStr.mpData->maStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +BOOL STRING::EqualsIgnoreCaseAscii( const STRCODE* pCharStr, xub_StrLen nIndex, xub_StrLen nLen ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Are there enough codes for comparing? + if ( nIndex > mpData->mnLen ) + return (*pCharStr == 0); + + return (ImplStringICompare( mpData->maStr+nIndex, pCharStr, nLen ) == 0); +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::Match( const STRING& rStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + // Ist dieser String leer + if ( !mpData->mnLen ) + return STRING_MATCH; + + // Suche bis Stringende nach dem ersten nicht uebereinstimmenden Zeichen + const STRCODE* pStr1 = mpData->maStr; + const STRCODE* pStr2 = rStr.mpData->maStr; + xub_StrLen i = 0; + while ( i < mpData->mnLen ) + { + // Stimmt das Zeichen nicht ueberein, dann abbrechen + if ( *pStr1 != *pStr2 ) + return i; + pStr1++; + pStr2++; + i++; + } + + return STRING_MATCH; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::Match( const STRCODE* pCharStr ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Ist dieser String leer + if ( !mpData->mnLen ) + return STRING_MATCH; + + // Suche bis Stringende nach dem ersten nicht uebereinstimmenden Zeichen + const STRCODE* pStr = mpData->maStr; + xub_StrLen i = 0; + while ( i < mpData->mnLen ) + { + // Stimmt das Zeichen nicht ueberein, dann abbrechen + if ( *pStr != *pCharStr ) + return i; + pStr++; + pCharStr++; + i++; + } + + return STRING_MATCH; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::Search( STRCODE c, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + while ( nIndex < nLen ) + { + if ( *pStr == c ) + return nIndex; + pStr++; + nIndex++; + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::Search( const STRING& rStr, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + xub_StrLen nStrLen = rStr.mpData->mnLen; + + // Falls die Laenge des uebergebenen Strings 0 ist oder der Index + // hinter dem String liegt, dann wurde der String nicht gefunden + if ( !nStrLen || (nIndex >= nLen) ) + return STRING_NOTFOUND; + + const STRCODE* pStr1 = mpData->maStr; + pStr1 += nIndex; + + if ( nStrLen == 1 ) + { + STRCODE cSearch = rStr.mpData->maStr[0]; + while ( nIndex < nLen ) + { + if ( *pStr1 == cSearch ) + return nIndex; + pStr1++; + nIndex++; + } + } + else + { + const STRCODE* pStr2 = rStr.mpData->maStr; + + // Nur innerhalb des Strings suchen + while ( (ULONG)nIndex+nStrLen <= nLen ) + { + // Stimmt der String ueberein + if ( ImplStringCompareWithoutZero( pStr1, pStr2, nStrLen ) == 0 ) + return nIndex; + pStr1++; + nIndex++; + } + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::Search( const STRCODE* pCharStr, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + xub_StrLen nStrLen = ImplStringLen( pCharStr ); + + // Falls die Laenge des uebergebenen Strings 0 ist oder der Index + // hinter dem String liegt, dann wurde der String nicht gefunden + if ( !nStrLen || (nIndex >= nLen) ) + return STRING_NOTFOUND; + + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + + if ( nStrLen == 1 ) + { + STRCODE cSearch = *pCharStr; + while ( nIndex < nLen ) + { + if ( *pStr == cSearch ) + return nIndex; + pStr++; + nIndex++; + } + } + else + { + // Nur innerhalb des Strings suchen + while ( (ULONG)nIndex+nStrLen <= nLen ) + { + // Stimmt der String ueberein + if ( ImplStringCompareWithoutZero( pStr, pCharStr, nStrLen ) == 0 ) + return nIndex; + pStr++; + nIndex++; + } + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchBackward( STRCODE c, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + if ( nIndex > mpData->mnLen ) + nIndex = (xub_StrLen)mpData->mnLen; + + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + + while ( nIndex ) + { + nIndex--; + pStr--; + if ( *pStr == c ) + return nIndex; + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchChar( const STRCODE* pChars, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + while ( nIndex < nLen ) + { + STRCODE c = *pStr; + const STRCODE* pCompStr = pChars; + while ( *pCompStr ) + { + if ( *pCompStr == c ) + return nIndex; + pCompStr++; + } + pStr++; + nIndex++; + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchCharBackward( const STRCODE* pChars, xub_StrLen nIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + if ( nIndex > mpData->mnLen ) + nIndex = (xub_StrLen)mpData->mnLen; + + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + + while ( nIndex ) + { + nIndex--; + pStr--; + + STRCODE c =*pStr; + const STRCODE* pCompStr = pChars; + while ( *pCompStr ) + { + if ( *pCompStr == c ) + return nIndex; + pCompStr++; + } + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchAndReplace( STRCODE c, STRCODE cRep, xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + const STRCODE* pStr = mpData->maStr; + pStr += nIndex; + while ( nIndex < nLen ) + { + if ( *pStr == c ) + { + ImplCopyData( this ); + mpData->maStr[nIndex] = cRep; + return nIndex; + } + pStr++; + nIndex++; + } + + return STRING_NOTFOUND; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchAndReplace( const STRING& rStr, const STRING& rRepStr, + xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rRepStr, STRING, DBGCHECKSTRING ); + + xub_StrLen nSPos = Search( rStr, nIndex ); + if ( nSPos != STRING_NOTFOUND ) + Replace( nSPos, rStr.Len(), rRepStr ); + + return nSPos; +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::SearchAndReplace( const STRCODE* pCharStr, const STRING& rRepStr, + xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rRepStr, STRING, DBGCHECKSTRING ); + + xub_StrLen nSPos = Search( pCharStr, nIndex ); + if ( nSPos != STRING_NOTFOUND ) + Replace( nSPos, ImplStringLen( pCharStr ), rRepStr ); + + return nSPos; +} + +// ----------------------------------------------------------------------- + +void STRING::SearchAndReplaceAll( STRCODE c, STRCODE cRep ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + xub_StrLen nLen = mpData->mnLen; + const STRCODE* pStr = mpData->maStr; + xub_StrLen nIndex = 0; + while ( nIndex < nLen ) + { + if ( *pStr == c ) + { + ImplCopyData( this ); + mpData->maStr[nIndex] = cRep; + } + pStr++; + nIndex++; + } +} + +// ----------------------------------------------------------------------- + +void STRING::SearchAndReplaceAll( const STRCODE* pCharStr, const STRING& rRepStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rRepStr, STRING, DBGCHECKSTRING ); + + xub_StrLen nCharLen = ImplStringLen( pCharStr ); + xub_StrLen nSPos = Search( pCharStr, 0 ); + while ( nSPos != STRING_NOTFOUND ) + { + Replace( nSPos, nCharLen, rRepStr ); + nSPos += rRepStr.Len(); + nSPos = Search( pCharStr, nSPos ); + } +} + +// ----------------------------------------------------------------------- + +void STRING::SearchAndReplaceAll( const STRING& rStr, const STRING& rRepStr ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rRepStr, STRING, DBGCHECKSTRING ); + + xub_StrLen nSPos = Search( rStr, 0 ); + while ( nSPos != STRING_NOTFOUND ) + { + Replace( nSPos, rStr.Len(), rRepStr ); + nSPos += rRepStr.Len(); + nSPos = Search( rStr, nSPos ); + } +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::GetTokenCount( STRCODE cTok ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Leerer String: TokenCount per Definition 0 + if ( !mpData->mnLen ) + return 0; + + xub_StrLen nTokCount = 1; + xub_StrLen nLen = mpData->mnLen; + const STRCODE* pStr = mpData->maStr; + xub_StrLen nIndex = 0; + while ( nIndex < nLen ) + { + // Stimmt das Tokenzeichen ueberein, dann erhoehe TokCount + if ( *pStr == cTok ) + nTokCount++; + pStr++; + nIndex++; + } + + return nTokCount; +} + +// ----------------------------------------------------------------------- + +void STRING::SetToken( xub_StrLen nToken, STRCODE cTok, const STRING& rStr, + xub_StrLen nIndex ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + + const STRCODE* pStr = mpData->maStr; + xub_StrLen nLen = (xub_StrLen)mpData->mnLen; + xub_StrLen nTok = 0; + xub_StrLen nFirstChar = nIndex; + xub_StrLen i = nFirstChar; + + // Bestimme die Token-Position und Laenge + pStr += i; + while ( i < nLen ) + { + // Stimmt das Tokenzeichen ueberein, dann erhoehe TokCount + if ( *pStr == cTok ) + { + nTok++; + + if ( nTok == nToken ) + nFirstChar = i+1; + else + { + if ( nTok > nToken ) + break; + } + } + + pStr++; + i++; + } + + if ( nTok >= nToken ) + Replace( nFirstChar, i-nFirstChar, rStr ); +} + +// ----------------------------------------------------------------------- + +STRING STRING::GetToken( xub_StrLen nToken, STRCODE cTok, xub_StrLen& rIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + const STRCODE* pStr = mpData->maStr; + xub_StrLen nLen = (xub_StrLen)mpData->mnLen; + xub_StrLen nTok = 0; + xub_StrLen nFirstChar = rIndex; + xub_StrLen i = nFirstChar; + + // Bestimme die Token-Position und Laenge + pStr += i; + while ( i < nLen ) + { + // Stimmt das Tokenzeichen ueberein, dann erhoehe TokCount + if ( *pStr == cTok ) + { + nTok++; + + if ( nTok == nToken ) + nFirstChar = i+1; + else + { + if ( nTok > nToken ) + break; + } + } + + pStr++; + i++; + } + + if ( nTok >= nToken ) + { + if ( i < nLen ) + rIndex = i+1; + else + rIndex = STRING_NOTFOUND; + return Copy( nFirstChar, i-nFirstChar ); + } + else + { + rIndex = STRING_NOTFOUND; + return STRING(); + } +} + +// ----------------------------------------------------------------------- + +xub_StrLen STRING::GetQuotedTokenCount( const STRING& rQuotedPairs, STRCODE cTok ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rQuotedPairs, STRING, DBGCHECKSTRING ); + DBG_ASSERT( !(rQuotedPairs.Len()%2), "String::GetQuotedTokenCount() - QuotedString%2 != 0" ); + DBG_ASSERT( rQuotedPairs.Search(cTok) == STRING_NOTFOUND, "String::GetQuotedTokenCount() - cTok in QuotedString" ); + + // Leerer String: TokenCount per Definition 0 + if ( !mpData->mnLen ) + return 0; + + xub_StrLen nTokCount = 1; + xub_StrLen nLen = mpData->mnLen; + xub_StrLen nQuotedLen = rQuotedPairs.Len(); + STRCODE cQuotedEndChar = 0; + const STRCODE* pQuotedStr = rQuotedPairs.mpData->maStr; + const STRCODE* pStr = mpData->maStr; + xub_StrLen nIndex = 0; + while ( nIndex < nLen ) + { + STRCODE c = *pStr; + if ( cQuotedEndChar ) + { + // Ende des Quotes erreicht ? + if ( c == cQuotedEndChar ) + cQuotedEndChar = 0; + } + else + { + // Ist das Zeichen ein Quote-Anfang-Zeichen ? + xub_StrLen nQuoteIndex = 0; + while ( nQuoteIndex < nQuotedLen ) + { + if ( pQuotedStr[nQuoteIndex] == c ) + { + cQuotedEndChar = pQuotedStr[nQuoteIndex+1]; + break; + } + else + nQuoteIndex += 2; + } + + // Stimmt das Tokenzeichen ueberein, dann erhoehe TokCount + if ( c == cTok ) + nTokCount++; + } + + pStr++; + nIndex++; + } + + return nTokCount; +} + +// ----------------------------------------------------------------------- + +STRING STRING::GetQuotedToken( xub_StrLen nToken, const STRING& rQuotedPairs, + STRCODE cTok, xub_StrLen& rIndex ) const +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rQuotedPairs, STRING, DBGCHECKSTRING ); + DBG_ASSERT( !(rQuotedPairs.Len()%2), "String::GetQuotedToken() - QuotedString%2 != 0" ); + DBG_ASSERT( rQuotedPairs.Search(cTok) == STRING_NOTFOUND, "String::GetQuotedToken() - cTok in QuotedString" ); + + const STRCODE* pStr = mpData->maStr; + const STRCODE* pQuotedStr = rQuotedPairs.mpData->maStr; + STRCODE cQuotedEndChar = 0; + xub_StrLen nQuotedLen = rQuotedPairs.Len(); + xub_StrLen nLen = (xub_StrLen)mpData->mnLen; + xub_StrLen nTok = 0; + xub_StrLen nFirstChar = rIndex; + xub_StrLen i = nFirstChar; + + // Bestimme die Token-Position und Laenge + pStr += i; + while ( i < nLen ) + { + STRCODE c = *pStr; + if ( cQuotedEndChar ) + { + // Ende des Quotes erreicht ? + if ( c == cQuotedEndChar ) + cQuotedEndChar = 0; + } + else + { + // Ist das Zeichen ein Quote-Anfang-Zeichen ? + xub_StrLen nQuoteIndex = 0; + while ( nQuoteIndex < nQuotedLen ) + { + if ( pQuotedStr[nQuoteIndex] == c ) + { + cQuotedEndChar = pQuotedStr[nQuoteIndex+1]; + break; + } + else + nQuoteIndex += 2; + } + + // Stimmt das Tokenzeichen ueberein, dann erhoehe TokCount + if ( c == cTok ) + { + nTok++; + + if ( nTok == nToken ) + nFirstChar = i+1; + else + { + if ( nTok > nToken ) + break; + } + } + } + + pStr++; + i++; + } + + if ( nTok >= nToken ) + { + if ( i < nLen ) + rIndex = i+1; + else + rIndex = STRING_NOTFOUND; + return Copy( nFirstChar, i-nFirstChar ); + } + else + { + rIndex = STRING_NOTFOUND; + return STRING(); + } +} + +// ----------------------------------------------------------------------- + +STRCODE* STRING::GetBufferAccess() +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Daten kopieren, wenn noetig + if ( mpData->mnLen ) + ImplCopyData( this ); + + // Pointer auf den String zurueckgeben + return mpData->maStr; +} + +// ----------------------------------------------------------------------- + +void STRING::ReleaseBufferAccess( xub_StrLen nLen ) +{ + // Hier ohne Funktionstest, da String nicht konsistent + DBG_CHKTHIS( STRING, NULL ); + DBG_ASSERT( mpData->mnRefCount == 1, "String::ReleaseCharStr() called for String with RefCount" ); + + if ( nLen > mpData->mnLen ) + nLen = ImplStringLen( mpData->maStr ); + + if ( !nLen ) + { + ImplDeleteData( mpData ); + ImplIncRefCount( &aImplEmptyStrData ); + mpData = &aImplEmptyStrData; + } + // Bei mehr als 8 Zeichen unterschied, kuerzen wir den Buffer + else if ( ((ULONG)nLen)+8 < mpData->mnLen ) + { + STRINGDATA* pNewData = ImplAllocData( nLen ); + memcpy( pNewData->maStr, mpData->maStr, nLen*sizeof( STRCODE ) ); + ImplDeleteData( mpData ); + mpData = pNewData; + } + else + mpData->mnLen = nLen; +} + +// ----------------------------------------------------------------------- + +STRCODE* STRING::AllocBuffer( xub_StrLen nLen ) +{ + DBG_CHKTHIS( STRING, DBGCHECKSTRING ); + + // Vorhandene Daten loeschen und neue anlegen + ImplDeleteData( mpData ); + if ( nLen ) + mpData = ImplAllocData( nLen ); + else + mpData = &aImplEmptyStrData; + + // Pointer auf den angelegten Buffer zurueckgeben + return mpData->maStr; +} + +// ----------------------------------------------------------------------- +#ifndef NOOLDSTRING +STRING operator + ( const STRING& rStr1, const STRING& rStr2 ) +{ + DBG_CHKOBJ( &rStr1, STRING, DBGCHECKSTRING ); + DBG_CHKOBJ( &rStr2, STRING, DBGCHECKSTRING ); + DBG_WARNING( "String::operator+(): Use String::operator+=() for better performence and smaller code" ); + + STRING aTmpStr( rStr1 ); + aTmpStr += rStr2; + return aTmpStr; +} + +// ----------------------------------------------------------------------- + +STRING operator + ( const STRING& rStr, const STRCODE* pCharStr ) +{ + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + DBG_WARNING( "String::operator+(): Use String::operator+=() for better performence and smaller code" ); + + STRING aTmpStr( rStr ); + aTmpStr += pCharStr; + return aTmpStr; +} + +// ----------------------------------------------------------------------- + +STRING operator + ( const STRCODE* pCharStr, const STRING& rStr ) +{ + DBG_CHKOBJ( &rStr, STRING, DBGCHECKSTRING ); + DBG_WARNING( "String::operator+(): - Use String::operator+=() for better performence and smaller code" ); + + STRING aTmpStr( pCharStr ); + aTmpStr += rStr; + return aTmpStr; +} +#endif diff --git a/tools/source/string/strucvt.cxx b/tools/source/string/strucvt.cxx new file mode 100644 index 000000000000..ab7190c662ff --- /dev/null +++ b/tools/source/string/strucvt.cxx @@ -0,0 +1,251 @@ +/************************************************************************* + * + * $RCSfile: strucvt.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +// ======================================================================= + +static UniStringData* ImplGetUniStringDataFromString( const char* pStr, sal_Size nLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_ASSERT( (eTextEncoding != 9) && + (eTextEncoding != RTL_TEXTENCODING_DONTKNOW) && + (eTextEncoding != RTL_TEXTENCODING_UCS2) && + (eTextEncoding != RTL_TEXTENCODING_UCS4), + "ByteString-->UniString: Wrong TextEncoding" ); + + if ( !nLen ) + { + ImplIncRefCount( &aImplEmptyStrData ); + return &aImplEmptyStrData; + } + +#ifndef NOOLDSTRING + if ( eTextEncoding == CHARSET_SYSTEM ) + eTextEncoding = GetSystemCharSet(); +#endif + nCvtFlags |= RTL_TEXTTOUNICODE_FLAGS_FLUSH; + + UniStringData* pData; + rtl_TextEncodingInfo aTextEncInfo; + rtl_TextToUnicodeConverter hConverter = rtl_createTextToUnicodeConverter( eTextEncoding ); + sal_uInt32 nInfo; + sal_Size nSrcBytes; + sal_Size nDestChars; + sal_Size nNewLen; + + // get TextEncodingInfo + aTextEncInfo.StructSize = sizeof( aTextEncInfo ); + rtl_getTextEncodingInfo( eTextEncoding, &aTextEncInfo ); + + // Zuerst konvertieren wir mit der wahrscheinlichen Anzahl + // der zu konvertierenden Zeichen + nNewLen = nLen/aTextEncInfo.AverageCharSize; + if ( nNewLen > STRING_MAXLEN ) + nNewLen = STRING_MAXLEN; + pData = ImplAllocData( (xub_StrLen)nNewLen ); + nDestChars = rtl_convertTextToUnicode( hConverter, 0, + pStr, nLen, + pData->maStr, nNewLen, + nCvtFlags, + &nInfo, &nSrcBytes ); + + // Buffer hat nicht gereicht, dann mit maximaler Buffergroesse + if ( (nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL) && + (nNewLen != STRING_MAXLEN) ) + { + rtl_freeMemory( pData ); + nNewLen = nLen; + if ( nNewLen > STRING_MAXLEN ) + nNewLen = STRING_MAXLEN; + pData = ImplAllocData( (xub_StrLen)nNewLen ); + nDestChars = rtl_convertTextToUnicode( hConverter, 0, + pStr, nLen, + pData->maStr, nNewLen, + nCvtFlags, + &nInfo, &nSrcBytes ); + } + + // String entsprechend der durch das Konvertieren tatsaechlich + // entstehenden Bytes anpassen + if ( !nDestChars ) + { + rtl_freeMemory( pData ); + ImplIncRefCount( &aImplEmptyStrData ); + pData = &aImplEmptyStrData; + } + else if ( nNewLen > nDestChars+8 ) + { + UniStringData* pTempData = ImplAllocData( (xub_StrLen)nDestChars ); + memcpy( pTempData->maStr, pData->maStr, nDestChars*sizeof( sal_Unicode ) ); + rtl_freeMemory( pData ); + pData = pTempData; + } + else + { + pData->mnLen = (xub_StrLen)nDestChars; + pData->maStr[nDestChars] = '\0'; + } + rtl_destroyTextToUnicodeConverter( hConverter ); + return pData; +} + +// ======================================================================= + +void UniString::InitStringRes( const char* pUTF8Str, xub_StrLen nLen ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + + mpData = ImplGetUniStringDataFromString( pUTF8Str, nLen, + RTL_TEXTENCODING_UTF8, + RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE | + RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT | + RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT ); +} + +// ======================================================================= + +UniString::UniString( const ByteString& rByteStr, rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + DBG_CHKOBJ( &rByteStr, ByteString, DbgCheckByteString ); + + mpData = ImplGetUniStringDataFromString( rByteStr.mpData->maStr, rByteStr.mpData->mnLen, + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +UniString::UniString( const ByteString& rByteStr, xub_StrLen nPos, xub_StrLen nLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + DBG_CHKOBJ( &rByteStr, ByteString, DbgCheckByteString ); + + // Stringlaenge ermitteln + if ( nPos > rByteStr.mpData->mnLen ) + nLen = 0; + else + { + // Laenge korrigieren, wenn noetig + xub_StrLen nMaxLen = rByteStr.mpData->mnLen-nPos; + if ( nLen > nMaxLen ) + nLen = nMaxLen; + } + + mpData = ImplGetUniStringDataFromString( rByteStr.mpData->maStr+nPos, nLen, + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +UniString::UniString( const char* pByteStr, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + DBG_ASSERT( pByteStr, "UniString::UniString() - pByteStr is NULL" ); + + mpData = ImplGetUniStringDataFromString( pByteStr, ImplStringLen( pByteStr ), + eTextEncoding, nCvtFlags ); +} + +// ----------------------------------------------------------------------- + +UniString::UniString( const char* pByteStr, xub_StrLen nLen, + rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + DBG_ASSERT( pByteStr, "UniString::UniString() - pByteStr is NULL" ); + + if ( nLen == STRING_LEN ) + nLen = ImplStringLen( pByteStr ); + + mpData = ImplGetUniStringDataFromString( pByteStr, nLen, + eTextEncoding, nCvtFlags ); +} + +// ======================================================================= + +UniString::UniString( const NAMESPACE_RTL(OUString)& rStr ) +{ + DBG_CTOR( UniString, DbgCheckUniString ); + + mpData = (UniStringData*)rStr.pData; + ImplIncRefCount( mpData ); +} + +// ----------------------------------------------------------------------- + +NAMESPACE_RTL(OUString)::OUString( const UniString& rStr ) +{ + pData = (rtl_uString*)rStr.mpData; + rtl_uString_acquire( pData ); +} + +// ----------------------------------------------------------------------- + +UniString& UniString::Assign( const NAMESPACE_RTL(OUString)& rStr ) +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + + rtl_uString_acquire( rStr.pData ); + ImplDeleteData( mpData ); + mpData = (UniStringData*)rStr.pData; + return *this; +} diff --git a/tools/source/string/tstring.cxx b/tools/source/string/tstring.cxx new file mode 100644 index 000000000000..9e8cda42b736 --- /dev/null +++ b/tools/source/string/tstring.cxx @@ -0,0 +1,304 @@ +/************************************************************************* + * + * $RCSfile: tstring.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <string.h> + +#ifndef _OSL_INTERLCK_H +#include <osl/interlck.h> +#endif +#ifndef _RTL_ALLOC_H +#include <rtl/alloc.h> +#endif +#ifndef _RTL_MEMORY_H +#include <rtl/memory.h> +#endif +#ifndef _RTL_TENCINFO_H +#include <rtl/tencinfo.h> +#endif + +#define private public +#include <string.hxx> +#undef private +#include <impstrg.hxx> + +// For shared byte convert tables +#ifndef _TOOLS_TOOLSIN_HXX +#include <toolsin.hxx> +#endif + +#include <debug.hxx> + +// ======================================================================= + +DBG_NAME( ByteString ); +DBG_NAMEEX( UniString ); + +// ----------------------------------------------------------------------- + +#define STRCODE sal_Char +#define STRING ByteString +#define STRINGDATA ByteStringData +#define DBGCHECKSTRING DbgCheckByteString + +// ----------------------------------------------------------------------- + +xub_StrLen ImplStringLen( const sal_Char* pStr ) +{ + const sal_Char* pTempStr = pStr; + while( *pTempStr ) + pTempStr++; + return (xub_StrLen)(pTempStr-pStr); +} + +// ----------------------------------------------------------------------- + +xub_StrLen ImplStringLen( const sal_Unicode* pStr ) +{ + const sal_Unicode* pTempStr = pStr; + while( *pTempStr ) + pTempStr++; + return (xub_StrLen)(pTempStr-pStr); +} + +// ----------------------------------------------------------------------- + +#include <strimp.cxx> +#include <strcvt.cxx> + +#ifndef NOOLDSTRING +#include <strold.cxx> +#endif + +// ----------------------------------------------------------------------- + +ByteString ByteString::CreateFromInt32( sal_Int32 n, sal_Int16 nRadix ) +{ + sal_Char aBuf[RTL_STR_MAX_VALUEOFINT32]; + return ByteString( aBuf, rtl_str_valueOfInt32( aBuf, n, nRadix ) ); +} + +// ----------------------------------------------------------------------- + +ByteString ByteString::CreateFromInt64( sal_Int64 n, sal_Int16 nRadix ) +{ + sal_Char aBuf[RTL_STR_MAX_VALUEOFINT64]; + return ByteString( aBuf, rtl_str_valueOfInt64( aBuf, n, nRadix ) ); +} + +// ----------------------------------------------------------------------- + +ByteString ByteString::CreateFromFloat( float f ) +{ + sal_Char aBuf[RTL_STR_MAX_VALUEOFFLOAT]; + return ByteString( aBuf, rtl_str_valueOfFloat( aBuf, f ) ); +} + +// ----------------------------------------------------------------------- + +ByteString ByteString::CreateFromDouble( double d ) +{ + sal_Char aBuf[RTL_STR_MAX_VALUEOFDOUBLE]; + return ByteString( aBuf, rtl_str_valueOfDouble( aBuf, d ) ); +} + +// ----------------------------------------------------------------------- + +sal_Int32 ByteString::ToInt32() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + return atoi( mpData->maStr ); +} + +// ----------------------------------------------------------------------- + +sal_Int64 ByteString::ToInt64() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + return atoi( mpData->maStr ); +} + +// ----------------------------------------------------------------------- + +float ByteString::ToFloat() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + return 0; +} + +// ----------------------------------------------------------------------- + +double ByteString::ToDouble() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + return 0; +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::IsLowerAscii() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + const sal_Char* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + if ( (*pStr >= 65) && (*pStr <= 90) ) + return FALSE; + + pStr++; + nIndex++; + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::IsUpperAscii() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + const sal_Char* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + if ( (*pStr >= 97) && (*pStr <= 122) ) + return FALSE; + + pStr++; + nIndex++; + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::IsAlphaAscii() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + const sal_Char* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + if ( !(((*pStr >= 97) && (*pStr <= 122)) || + ((*pStr >= 65) && (*pStr <= 90))) ) + return FALSE; + + pStr++; + nIndex++; + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::IsNumericAscii() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + const sal_Char* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + if ( !((*pStr >= 48) && (*pStr <= 57)) ) + return FALSE; + + pStr++; + nIndex++; + } + + return TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL ByteString::IsAlphaNumericAscii() const +{ + DBG_CHKTHIS( ByteString, DbgCheckByteString ); + + xub_StrLen nIndex = 0; + xub_StrLen nLen = mpData->mnLen; + const sal_Char* pStr = mpData->maStr; + while ( nIndex < nLen ) + { + if ( !(((*pStr >= 97) && (*pStr <= 122)) || + ((*pStr >= 65) && (*pStr <= 90)) || + ((*pStr >= 48) && (*pStr <= 57))) ) + return FALSE; + + pStr++; + nIndex++; + } + + return TRUE; +} diff --git a/tools/source/string/tustring.cxx b/tools/source/string/tustring.cxx new file mode 100644 index 000000000000..22c894063441 --- /dev/null +++ b/tools/source/string/tustring.cxx @@ -0,0 +1,173 @@ +/************************************************************************* + * + * $RCSfile: tustring.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:09 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <string.h> + +#ifndef _OSL_INTERLCK_H +#include <osl/interlck.h> +#endif +#ifndef _RTL_ALLOC_H +#include <rtl/alloc.h> +#endif +#ifndef _RTL_MEMORY_H +#include <rtl/memory.h> +#endif +#ifndef _RTL_TENCINFO_H +#include <rtl/tencinfo.h> +#endif + +#define private public +#include <string.hxx> +#undef private +#include <impstrg.hxx> + +#include <debug.hxx> + +// ======================================================================= + +DBG_NAME( UniString ); +DBG_NAMEEX( ByteString ); + +// ----------------------------------------------------------------------- + +#define STRCODE sal_Unicode +#define STRING UniString +#define STRINGDATA UniStringData +#define DBGCHECKSTRING DbgCheckUniString + +// ----------------------------------------------------------------------- + +#include <strimp.cxx> +#include <strucvt.cxx> +#include <strascii.cxx> + +#ifndef NOOLDSTRING +#include <struold.cxx> +#endif + +// ----------------------------------------------------------------------- + +UniString UniString::CreateFromInt32( sal_Int32 n, sal_Int16 nRadix ) +{ + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT32]; + return UniString( aBuf, rtl_ustr_valueOfInt32( aBuf, n, nRadix ) ); +} + +// ----------------------------------------------------------------------- + +UniString UniString::CreateFromInt64( sal_Int64 n, sal_Int16 nRadix ) +{ + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT64]; + return UniString( aBuf, rtl_ustr_valueOfInt64( aBuf, n, nRadix ) ); +} + +// ----------------------------------------------------------------------- + +UniString UniString::CreateFromFloat( float f ) +{ + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFFLOAT]; + return UniString( aBuf, rtl_ustr_valueOfFloat( aBuf, f ) ); +} + +// ----------------------------------------------------------------------- + +UniString UniString::CreateFromDouble( double d ) +{ + sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFDOUBLE]; + return UniString( aBuf, rtl_ustr_valueOfDouble( aBuf, d ) ); +} + +// ----------------------------------------------------------------------- + +sal_Int32 UniString::ToInt32() const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + + return rtl_ustr_toInt32( mpData->maStr, 10 ); +} + +// ----------------------------------------------------------------------- + +sal_Int64 UniString::ToInt64() const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + + return rtl_ustr_toInt64( mpData->maStr, 10 ); +} + +// ----------------------------------------------------------------------- + +float UniString::ToFloat() const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + + return rtl_ustr_toFloat( mpData->maStr ); +} + +// ----------------------------------------------------------------------- + +double UniString::ToDouble() const +{ + DBG_CHKTHIS( UniString, DbgCheckUniString ); + + return rtl_ustr_toDouble( mpData->maStr ); +} + diff --git a/tools/source/zcodec/makefile.mk b/tools/source/zcodec/makefile.mk new file mode 100644 index 000000000000..f7f3fcdf21e3 --- /dev/null +++ b/tools/source/zcodec/makefile.mk @@ -0,0 +1,80 @@ +#************************************************************************* +# +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.1.1.1 $ +# +# last change: $Author: hr $ $Date: 2000-09-18 17:03:10 $ +# +# The Contents of this file are made available subject to the terms of +# either of the following licenses +# +# - GNU Lesser General Public License Version 2.1 +# - Sun Industry Standards Source License Version 1.1 +# +# Sun Microsystems Inc., October, 2000 +# +# GNU Lesser General Public License Version 2.1 +# ============================================= +# Copyright 2000 by Sun Microsystems, Inc. +# 901 San Antonio Road, Palo Alto, CA 94303, USA +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License version 2.1, as published by the Free Software Foundation. +# +# This library 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 for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# +# +# Sun Industry Standards Source License Version 1.1 +# ================================================= +# The contents of this file are subject to the Sun Industry Standards +# Source License Version 1.1 (the "License"); You may not use this file +# except in compliance with the License. You may obtain a copy of the +# License at http://www.openoffice.org/license.html. +# +# Software provided under this License is provided on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, +# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, +# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. +# See the License for the specific provisions governing your rights and +# obligations concerning the Software. +# +# The Initial Developer of the Original Code is: Sun Microsystems, Inc. +# +# Copyright: 2000 by Sun Microsystems, Inc. +# +# All Rights Reserved. +# +# Contributor(s): _______________________________________ +# +# +# +#************************************************************************* + +PRJ=..$/.. + +PRJNAME=tools +TARGET=zcodec + +# --- Settings ----------------------------------------------------- + +.INCLUDE : svpre.mk +.INCLUDE : settings.mk +.INCLUDE : sv.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= $(SLO)$/zcodec.obj + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk diff --git a/tools/source/zcodec/zcodec.cxx b/tools/source/zcodec/zcodec.cxx new file mode 100644 index 000000000000..86230b275004 --- /dev/null +++ b/tools/source/zcodec/zcodec.cxx @@ -0,0 +1,524 @@ +/************************************************************************* + * + * $RCSfile: zcodec.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 17:03:10 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (the "License"); You may not use this file + * except in compliance with the License. You may obtain a copy of the + * License at http://www.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _STREAM_HXX +#include "stream.hxx" +#endif +#ifndef _ZLIB_H +#include "zlib/zlib.h" +#endif +#ifndef _ZCODEC_HXX +#include "zcodec.hxx" +#endif +#ifndef _RTL_CRC_H_ +#include <rtl/crc.h> +#endif + +// ----------- +// - Defines - +// ----------- + +#define PZSTREAM ((z_stream*) mpsC_Stream) + +/* gzip flag byte */ +#define GZ_ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define GZ_HEAD_CRC 0x02 /* bit 1 set: header CRC present */ +#define GZ_EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define GZ_ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define GZ_COMMENT 0x10 /* bit 4 set: file comment present */ +#define GZ_RESERVED 0xE0 /* bits 5..7: reserved */ + +static int gz_magic[2] = { 0x1f, 0x8b }; /* gzip magic header */ + + +// ---------- +// - ZCodec - +// ---------- + +ZCodec::ZCodec( ULONG nInBufSize, ULONG nOutBufSize, ULONG nMemUsage ) +{ + mnMemUsage = nMemUsage; + mnInBufSize = nInBufSize; + mnOutBufSize = nOutBufSize; + mpsC_Stream = new z_stream; +} + +ZCodec::ZCodec( void ) +{ + mnMemUsage = MAX_MEM_USAGE; + mnInBufSize = DEFAULT_IN_BUFSIZE; + mnOutBufSize = DEFAULT_OUT_BUFSIZE; + mpsC_Stream = new z_stream; +} + +// ------------------------------------------------------------------------ + +ZCodec::~ZCodec() +{ + delete (z_stream*) mpsC_Stream; +} + +// ------------------------------------------------------------------------ + +void ZCodec::BeginCompression( ULONG nCompressMethod ) +{ + mbInit = 0; + mbStatus = TRUE; + mbFinish = FALSE; + mpIStm = mpOStm = NULL; + mnInToRead = 0xffffffff; + mpInBuf = mpOutBuf = NULL; + PZSTREAM->total_out = PZSTREAM->total_in = 0; + mnCompressMethod = nCompressMethod; + PZSTREAM->zalloc = ( alloc_func )0; + PZSTREAM->zfree = ( free_func )0; + PZSTREAM->opaque = ( voidpf )0; + PZSTREAM->avail_out = PZSTREAM->avail_in = 0; +} + +// ------------------------------------------------------------------------ + +long ZCodec::EndCompression() +{ + long retvalue; + + if ( mbInit != 0 ) + { + if ( mbInit & 2 ) // 1->decompress, 3->compress + { + do + { + ImplWriteBack(); + } + while ( deflate( PZSTREAM, Z_FINISH ) != Z_STREAM_END ); + + ImplWriteBack(); + + retvalue = PZSTREAM->total_in; + deflateEnd( PZSTREAM ); + } + else + { + retvalue = PZSTREAM->total_out; + inflateEnd( PZSTREAM ); + } + delete[] mpOutBuf; + delete[] mpInBuf; + } + return ( mbStatus ) ? retvalue : -1; +} + + +// ------------------------------------------------------------------------ + +long ZCodec::Compress( SvStream& rIStm, SvStream& rOStm ) +{ + char err; + long nOldTotal_In = PZSTREAM->total_in; + + if ( mbInit == 0 ) + { + mpIStm = &rIStm; + mpOStm = &rOStm; + ImplInitBuf( FALSE ); + mpInBuf = new BYTE[ mnInBufSize ]; + } + while (( PZSTREAM->avail_in = mpIStm->Read( PZSTREAM->next_in = mpInBuf, mnInBufSize )) != 0 ) + { + if ( PZSTREAM->avail_out == 0 ) + ImplWriteBack(); + err = deflate( PZSTREAM, Z_NO_FLUSH ); + if ( err < 0 ) + { + mbStatus = FALSE; + break; + } + }; + return ( mbStatus ) ? PZSTREAM->total_in - nOldTotal_In : -1; +} + +// ------------------------------------------------------------------------ + +long ZCodec::Decompress( SvStream& rIStm, SvStream& rOStm ) +{ + char err; + ULONG nInToRead; + long nOldTotal_Out = PZSTREAM->total_out; + + if ( mbFinish ) + return PZSTREAM->total_out - nOldTotal_Out; + + if ( mbInit == 0 ) + { + mpIStm = &rIStm; + mpOStm = &rOStm; + ImplInitBuf( TRUE ); + PZSTREAM->next_out = mpOutBuf = new BYTE[ PZSTREAM->avail_out = mnOutBufSize ]; + } + do + { + if ( PZSTREAM->avail_out == 0 ) ImplWriteBack(); + if ( PZSTREAM->avail_in == 0 && mnInToRead ) + { + nInToRead = ( mnInBufSize > mnInToRead ) ? mnInToRead : mnInBufSize; + PZSTREAM->avail_in = mpIStm->Read( PZSTREAM->next_in = mpInBuf, nInToRead ); + mnInToRead -= nInToRead; + + if ( mnCompressMethod & ZCODEC_UPDATE_CRC ) + mnCRC = UpdateCRC( mnCRC, mpInBuf, nInToRead ); + + } + err = inflate( PZSTREAM, Z_NO_FLUSH ); + if ( err < 0 ) + { + mbStatus = FALSE; + break; + } + + } + while ( ( err != Z_STREAM_END) && ( PZSTREAM->avail_in || mnInToRead ) ); + ImplWriteBack(); + + if ( err == Z_STREAM_END ) + mbFinish = TRUE; + return ( mbStatus ) ? PZSTREAM->total_out - nOldTotal_Out : -1; +} + +// ------------------------------------------------------------------------ + +long ZCodec::Write( SvStream& rOStm, const BYTE* pData, ULONG nSize ) +{ + if ( mbInit == 0 ) + { + mpOStm = &rOStm; + ImplInitBuf( FALSE ); + } + + PZSTREAM->avail_in = nSize; + PZSTREAM->next_in = (unsigned char*)pData; + + while ( PZSTREAM->avail_in || ( PZSTREAM->avail_out == 0 ) ) + { + if ( PZSTREAM->avail_out == 0 ) + ImplWriteBack(); + + if ( deflate( PZSTREAM, Z_NO_FLUSH ) < 0 ) + { + mbStatus = FALSE; + break; + } + } + return ( mbStatus ) ? nSize : -1; +} + +// ------------------------------------------------------------------------ + +long ZCodec::Read( SvStream& rIStm, BYTE* pData, ULONG nSize ) +{ + char err; + ULONG nInToRead; + + if ( mbFinish ) + return 0; // PZSTREAM->total_out; + + mpIStm = &rIStm; + if ( mbInit == 0 ) + { + ImplInitBuf( TRUE ); + } + PZSTREAM->avail_out = nSize; + PZSTREAM->next_out = pData; + do + { + if ( PZSTREAM->avail_in == 0 && mnInToRead ) + { + nInToRead = (mnInBufSize > mnInToRead) ? mnInToRead : mnInBufSize; + PZSTREAM->avail_in = mpIStm->Read ( + PZSTREAM->next_in = mpInBuf, nInToRead); + mnInToRead -= nInToRead; + + if ( mnCompressMethod & ZCODEC_UPDATE_CRC ) + mnCRC = UpdateCRC( mnCRC, mpInBuf, nInToRead ); + + } + err = inflate( PZSTREAM, Z_NO_FLUSH ); + if ( err < 0 ) + { + // Accept Z_BUF_ERROR as EAGAIN or EWOULDBLOCK. + mbStatus = (err == Z_BUF_ERROR); + break; + } + } + while ( (err != Z_STREAM_END) && + (PZSTREAM->avail_out != 0) && + (PZSTREAM->avail_in || mnInToRead) ); + if ( err == Z_STREAM_END ) + mbFinish = TRUE; + + return (mbStatus ? nSize - PZSTREAM->avail_out : -1); +} + +// ------------------------------------------------------------------------ + +#pragma optimize ("",off) + +long ZCodec::ReadAsynchron( SvStream& rIStm, BYTE* pData, ULONG nSize ) +{ + char err; + ULONG nInToRead; + + if ( mbFinish ) + return 0; // PZSTREAM->total_out; + + if ( mbInit == 0 ) + { + mpIStm = &rIStm; + ImplInitBuf( TRUE ); + } + PZSTREAM->avail_out = nSize; + PZSTREAM->next_out = pData; + do + { + if ( PZSTREAM->avail_in == 0 && mnInToRead ) + { + nInToRead = (mnInBufSize > mnInToRead) ? mnInToRead : mnInBufSize; + + ULONG nStreamPos = rIStm.Tell(); + rIStm.Seek( STREAM_SEEK_TO_END ); + ULONG nMaxPos = rIStm.Tell(); + rIStm.Seek( nStreamPos ); + if ( ( nMaxPos - nStreamPos ) < nInToRead ) + { + rIStm.SetError( ERRCODE_IO_PENDING ); + break; + } + + PZSTREAM->avail_in = mpIStm->Read ( + PZSTREAM->next_in = mpInBuf, nInToRead); + mnInToRead -= nInToRead; + + if ( mnCompressMethod & ZCODEC_UPDATE_CRC ) + mnCRC = UpdateCRC( mnCRC, mpInBuf, nInToRead ); + + } + err = inflate( PZSTREAM, Z_NO_FLUSH ); + if ( err < 0 ) + { + // Accept Z_BUF_ERROR as EAGAIN or EWOULDBLOCK. + mbStatus = (err == Z_BUF_ERROR); + break; + } + } + while ( (err != Z_STREAM_END) && + (PZSTREAM->avail_out != 0) && + (PZSTREAM->avail_in || mnInToRead) ); + if ( err == Z_STREAM_END ) + mbFinish = TRUE; + + return (mbStatus ? nSize - PZSTREAM->avail_out : -1); +} + +#pragma optimize ("",on) + +// ------------------------------------------------------------------------ + +void ZCodec::ImplWriteBack() +{ + ULONG nAvail = mnOutBufSize - PZSTREAM->avail_out; + + if ( nAvail ) + { + if ( mbInit & 2 && ( mnCompressMethod & ZCODEC_UPDATE_CRC ) ) + mnCRC = UpdateCRC( mnCRC, mpOutBuf, nAvail ); + mpOStm->Write( PZSTREAM->next_out = mpOutBuf, nAvail ); + PZSTREAM->avail_out = mnOutBufSize; + } +} + +// ------------------------------------------------------------------------ + +void ZCodec::SetBreak( ULONG nInToRead ) +{ + mnInToRead = nInToRead; +} + +// ------------------------------------------------------------------------ + +ULONG ZCodec::GetBreak( void ) +{ + return ( mnInToRead + PZSTREAM->avail_in ); +} + +// ------------------------------------------------------------------------ + +void ZCodec::SetCRC( ULONG nCRC ) +{ + mnCRC = nCRC; +} + +// ------------------------------------------------------------------------ + +ULONG ZCodec::GetCRC() +{ + return mnCRC; +} + +// ------------------------------------------------------------------------ + +void ZCodec::ImplInitBuf ( BOOL nIOFlag ) +{ + if ( mbInit == 0 ) + { + if ( nIOFlag ) + { + mbInit = 1; + if ( mbStatus && ( mnCompressMethod & ZCODEC_GZ_LIB ) ) + { + BYTE n1, n2, j, nMethod, nFlags; + for ( int i = 0; i < 2; i++ ) // gz - magic number + { + *mpIStm >> j; + if ( j != gz_magic[ i ] ) + mbStatus = FALSE; + } + *mpIStm >> nMethod; + *mpIStm >> nFlags; + if ( nMethod != Z_DEFLATED ) + mbStatus = FALSE; + if ( ( nFlags & GZ_RESERVED ) != 0 ) + mbStatus = FALSE; + /* Discard time, xflags and OS code: */ + mpIStm->SeekRel( 6 ); + /* skip the extra field */ + if ( nFlags & GZ_EXTRA_FIELD ) + { + *mpIStm >> n1 >> n2; + mpIStm->SeekRel( n1 + ( n2 << 8 ) ); + } + /* skip the original file name */ + if ( nFlags & GZ_ORIG_NAME) + { + do + { + *mpIStm >> j; + } + while ( j && !mpIStm->IsEof() ); + } + /* skip the .gz file comment */ + if ( nFlags & GZ_COMMENT ) + { + do + { + *mpIStm >> j; + } + while ( j && !mpIStm->IsEof() ); + } + /* skip the header crc */ + if ( nFlags & GZ_HEAD_CRC ) + mpIStm->SeekRel( 2 ); + if ( mbStatus ) + mbStatus = ( inflateInit2( PZSTREAM, -MAX_WBITS) != Z_OK ) ? FALSE : TRUE; + } + else + { + mbStatus = ( inflateInit( PZSTREAM ) >= 0 ); + } + mpInBuf = new BYTE[ mnInBufSize ]; + } + else + { + mbInit = 3; + + mbStatus = ( deflateInit2_( PZSTREAM, mnCompressMethod & 0xff, Z_DEFLATED, + MAX_WBITS, mnMemUsage, ( mnCompressMethod >> 8 ) & 0xff, + ZLIB_VERSION, sizeof( z_stream ) ) >= 0 ); + + PZSTREAM->next_out = mpOutBuf = new BYTE[ PZSTREAM->avail_out = mnOutBufSize ]; + } + } +} + +// ------------------------------------------------------------------------ + +ULONG ZCodec::UpdateCRC ( ULONG nLatestCRC, ULONG nNumber ) +{ + +#ifdef __LITTLEENDIAN + nNumber = SWAPLONG( nNumber ); +#endif + return rtl_crc32( nLatestCRC, &nNumber, 4 ); +} + +// ------------------------------------------------------------------------ + +ULONG ZCodec::UpdateCRC ( ULONG nLatestCRC, BYTE* pSource, long nDatSize) +{ + return rtl_crc32( nLatestCRC, pSource, nDatSize ); +} + +// ------------------------------------------------------------------------ + +void GZCodec::BeginCompression( ULONG nCompressMethod ) +{ + ZCodec::BeginCompression( nCompressMethod | ZCODEC_GZ_LIB ); +}; + + |