removetooltypes01: rebase to DEV300_m96

6 files changed, 1009 insertions, 24 deletions

diff --git a/soldep/bootstrp/appdef.cxx b/soldep/bootstrp/appdef.cxx
index 8ce777888781..ac167d508027 100644
--- a/soldep/bootstrp/appdef.cxx
+++ b/soldep/bootstrp/appdef.cxx
@@ -29,7 +29,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <appdef.hxx>
+#include <soldep/appdef.hxx>
 
 const char* GetDefStandList()
 {
diff --git a/soldep/bootstrp/command.cxx b/soldep/bootstrp/command.cxx
new file mode 100644
index 000000000000..39a10093c12b
--- /dev/null
+++ b/soldep/bootstrp/command.cxx
@@ -0,0 +1,683 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifdef SCO
+#define _IOSTREAM_H
+#endif
+
+#include <tools/fsys.hxx>
+#include <tools/stream.hxx>
+#include "soldep/command.hxx"
+#include <tools/debug.hxx>
+#include <soldep/appdef.hxx>
+
+#ifdef _MSC_VER
+#pragma warning (push,1)
+#endif
+
+#include <iostream>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+
+#ifdef _MSC_VER
+#pragma warning (pop)
+#endif
+
+//#define MH_TEST2  1           // fuers direkte Testen
+
+#if defined(WNT) || defined(OS2)
+#ifdef _MSC_VER
+#pragma warning (push,1)
+#endif
+#include <process.h>    // for _SPAWN
+#ifdef _MSC_VER
+#pragma warning (pop)
+#endif
+#endif
+#ifdef UNX
+#include <sys/types.h>
+#include <unistd.h>
+#if ( defined NETBSD ) || defined (FREEBSD) || defined (AIX) \
+    || defined (HPUX) || defined (MACOSX)
+#include <sys/wait.h>
+#else
+#include <wait.h>
+#endif
+#define P_WAIT 1        // erstmal einen dummz
+#endif
+
+#if defined WNT
+#include <tools/svwin.h>
+#endif
+
+#if defined(WNT) || defined(OS2)
+#define     cPathSeperator ';'
+#endif
+#ifdef UNX
+#define     cPathSeperator  ':'
+#endif
+
+/*****************************************************************************/
+CommandLine::CommandLine(sal_Bool bWrite)
+/*****************************************************************************/
+                : bTmpWrite(bWrite)
+{
+    CommandBuffer = new char [1];
+    if (CommandBuffer == NULL) {
+        //cout << "Error: nospace" << endl;
+        exit(0);
+    }
+    CommandBuffer[0] = '\0';
+    nArgc = 0;
+    ppArgv = new char * [1];
+    ppArgv[0] = NULL;
+
+    ComShell = new char [128];
+    char* pTemp = getenv("COMMAND_SHELL");
+    if(!pTemp)
+        strcpy(ComShell,COMMAND_SHELL);
+    else
+        strcpy(ComShell,pTemp);
+
+    strcpy(&ComShell[strlen(ComShell)]," -C ");
+}
+
+/*****************************************************************************/
+CommandLine::CommandLine(const char *CommandString, sal_Bool bWrite)
+/*****************************************************************************/
+                : bTmpWrite(bWrite)
+{
+    CommandBuffer = new char [1];
+    if (CommandBuffer == NULL) {
+        //cout << "Error: nospace" << endl;
+        exit(0);
+    }
+    nArgc = 0;
+    ppArgv = new char * [1];
+    ppArgv[0] = NULL;
+
+    ComShell = new char [128];
+    char* pTemp = getenv("COMMAND_SHELL");
+    if(!pTemp)
+        strcpy(ComShell,COMMAND_SHELL);
+    else
+        strcpy(ComShell,pTemp);
+
+    strcpy(&ComShell[strlen(ComShell)]," -C ");
+
+    BuildCommand(CommandString);
+}
+
+/*****************************************************************************/
+CommandLine::CommandLine(const CommandLine& CCommandLine, sal_Bool bWrite)
+/*****************************************************************************/
+                : bTmpWrite(bWrite)
+{
+    CommandBuffer = new char [1];
+    if (CommandBuffer == NULL) {
+        //cout << "Error: nospace" << endl;
+        exit(0);
+    }
+    nArgc = 0;
+    ppArgv = new char * [1];
+    ppArgv[0] = NULL;
+
+    ComShell = new char [128];
+    char* pTemp = getenv("COMMAND_SHELL");
+    if(!pTemp)
+        strcpy(ComShell,COMMAND_SHELL);
+    else
+        strcpy(ComShell,pTemp);
+
+    strcpy(&ComShell[strlen(ComShell)]," -C ");
+
+    BuildCommand(CCommandLine.CommandBuffer);
+}
+
+/*****************************************************************************/
+CommandLine::~CommandLine()
+/*****************************************************************************/
+{
+    delete [] CommandBuffer;
+    delete [] ComShell;
+    //for (int i = 0; ppArgv[i] != '\0'; i++) {
+    for (int i = 0; ppArgv[i] != 0; i++) {
+        delete [] ppArgv[i];
+    }
+    delete [] ppArgv;
+
+}
+
+/*****************************************************************************/
+CommandLine& CommandLine::operator=(const CommandLine& CCommandLine)
+/*****************************************************************************/
+{
+    strcpy (CommandBuffer, CCommandLine.CommandBuffer);
+    for (int i = 0; i != nArgc; i++) {
+        delete [] ppArgv[i];
+    }
+    delete [] ppArgv;
+        ppArgv = new char * [1];
+        ppArgv[0] = NULL;
+    BuildCommand(CommandBuffer);
+    return *this;
+}
+
+/*****************************************************************************/
+CommandLine& CommandLine::operator=(const char *CommandString)
+/*****************************************************************************/
+{
+    strcpy (CommandBuffer, CommandString);
+    for (int i = 0; i != nArgc; i++) {
+        delete [] ppArgv[i];
+    }
+    delete [] ppArgv;
+        ppArgv = new char * [1];
+        ppArgv[0] = NULL;
+    BuildCommand(CommandBuffer);
+
+    return *this;
+}
+
+/*****************************************************************************/
+void CommandLine::Print()
+/*****************************************************************************/
+{
+    //cout << "******* start print *******" << endl;
+    //cout << "nArgc = " << nArgc << endl;
+    //cout << "CommandBuffer = " << CommandBuffer << endl;
+    for (int i = 0; ppArgv[i] != NULL; i++) {
+        //cout << "ppArgv[" << i << "] = " << ppArgv[i] << endl;
+    }
+    //cout << "******** end print ********" << endl;
+}
+
+/*****************************************************************************/
+void CommandLine::BuildCommand(const char *CommandString)
+/*****************************************************************************/
+{
+    int index = 0, pos=0;
+    char buffer[1024];
+    char WorkString[1024];
+
+    strcpy(WorkString,CommandString);
+
+    //falls LogWindow -> in tmpfile schreiben
+    if(bTmpWrite)
+    {
+        strcpy(&WorkString[strlen(WorkString)]," >&");
+        strcpy(&WorkString[strlen(WorkString)],getenv("TMP"));
+        strcpy(&WorkString[strlen(WorkString)],TMPNAME);
+    }
+
+    // delete old memory and get some new memory for CommandBuffer
+
+    delete [] CommandBuffer;
+    CommandBuffer =  new char [strlen(ComShell)+strlen(WorkString)+1];
+    if (CommandBuffer == NULL) {
+        //cout << "Error: nospace" << endl;
+        exit(0);
+    }
+    strcpy (CommandBuffer, ComShell);
+    strcpy (&CommandBuffer[strlen(ComShell)], WorkString);
+
+    CommandString = CommandBuffer;
+
+    // get the number of tokens
+    Strtokens(CommandString);
+
+    // delete the space for the old CommandLine
+
+    for (int i = 0; ppArgv[i] != 0; i++) {
+        delete [] ppArgv[i];
+    }
+    delete [] ppArgv;
+
+    /* get space for the new command line */
+
+    ppArgv = (char **) new char * [nArgc+1];
+    if (ppArgv == NULL) {
+        //cout << "Error: no space" << endl;
+        exit(0);
+    }
+
+    // flush the white space
+
+    while ( isspace(*CommandString) )
+        CommandString++;
+
+    index = 0;
+
+    // start the loop to build all the individual tokens
+
+    while (*CommandString != '\0') {
+
+        pos = 0;
+
+        // copy the token until white space is found
+
+        while ( !isspace(*CommandString) && *CommandString != '\0') {
+
+            buffer[pos++] = *CommandString++;
+
+        }
+
+        buffer[pos] = '\0';
+
+        // get space for the individual tokens
+
+        ppArgv[index] = (char *) new char [strlen(buffer)+1];
+        if (ppArgv[index] == NULL) {
+            //cout << "Error: nospace" << endl;
+            exit(0);
+        }
+
+        // copy the token
+
+        strcpy (ppArgv[index++], buffer);
+
+        // flush while space
+
+        while ( isspace(*CommandString) )
+            CommandString++;
+
+    }
+
+    // finish by setting the las pointer to NULL
+    ppArgv[nArgc]= NULL;
+
+}
+
+/*****************************************************************************/
+void CommandLine::Strtokens(const char *CommandString)
+/*****************************************************************************/
+{
+    int count = 0;
+    const char *temp;
+
+    temp = CommandString;
+
+    /* bypass white space */
+
+    while (isspace(*temp)) temp++;
+
+    for (count=0; *temp != '\0'; count++) {
+
+        /* continue until white space of string terminator is found */
+
+        while ((!isspace(*temp)) && (*temp != '\0')) temp++;
+
+        /* bypass white space */
+
+        while (isspace(*temp)) temp++;
+
+    }
+    nArgc = count;
+}
+
+/*****************************************************************************/
+CCommand::CCommand( ByteString &rString )
+/*****************************************************************************/
+{
+    rString.SearchAndReplace( '\t', ' ' );
+    aCommand = rString.GetToken( 0, ' ' );
+    aCommandLine = Search( "PATH" );
+#ifndef UNX
+    aCommandLine += " /c ";
+#else
+    aCommandLine += " -c ";
+#endif
+
+    ByteString sCmd( rString.GetToken( 0, ' ' ));
+    ByteString sParam( rString.Copy( sCmd.Len()));
+
+    aCommandLine += Search( "PATH", sCmd );
+    aCommandLine += sParam;
+
+    ImplInit();
+}
+
+/*****************************************************************************/
+CCommand::CCommand( const char *pChar )
+/*****************************************************************************/
+{
+    ByteString aString = pChar;
+    aString.SearchAndReplace( '\t', ' ' );
+    aCommand = aString.GetToken( 0, ' ' );
+
+    aCommandLine = Search( "PATH" );
+#ifndef UNX
+    aCommandLine += " /c ";
+#else
+    aCommandLine += " -c ";
+#endif
+    ByteString rString( pChar );
+
+    ByteString sCmd( rString.GetToken( 0, ' ' ));
+    ByteString sParam( rString.Copy( sCmd.Len()));
+
+    aCommandLine += Search( "PATH", sCmd );
+    aCommandLine += sParam;
+
+    ImplInit();
+}
+
+/*****************************************************************************/
+void CCommand::ImplInit()
+/*****************************************************************************/
+{
+    char pTmpStr[255];
+    size_t *pPtr;
+    char *pChar;
+    int nVoid = sizeof( size_t * );
+    nArgc = aCommandLine.GetTokenCount(' ');
+    sal_uIntPtr nLen = aCommandLine.Len();
+
+    ppArgv = (char **) new char[ (sal_uIntPtr)(nLen + nVoid * (nArgc +2) + nArgc ) ];
+    pChar = (char *) ppArgv + ( (1+nArgc) * nVoid );
+    pPtr = (size_t *) ppArgv;
+    for ( xub_StrLen i=0; i<nArgc; i++ )
+    {
+        (void) strcpy( pTmpStr, aCommandLine.GetToken(i, ' ' ).GetBuffer() );
+        size_t nStrLen = strlen( pTmpStr ) + 1;
+        strcpy( pChar, pTmpStr );
+        *pPtr = (sal_uIntPtr) pChar;
+        pChar += nStrLen;
+        pPtr += 1;
+#ifdef UNX
+        if ( i == 1 )
+        {
+            sal_uInt16 nWo = aCommandLine.Search("csh -c ");
+            if (nWo != STRING_NOTFOUND)
+                aCommandLine.Erase(0, nWo + 7);
+            else
+                aCommandLine.Erase(0, 16);
+            i = nArgc;
+            strcpy( pChar, aCommandLine.GetBuffer() );
+            *pPtr = (sal_uIntPtr) pChar;
+            pPtr += 1;
+        }
+#endif
+    }
+    *pPtr = 0;
+}
+
+/*****************************************************************************/
+CCommand::operator int()
+/*****************************************************************************/
+{
+    int nRet;
+#if defined WNT
+    nRet = _spawnv( P_WAIT, ppArgv[0], (const char **) ppArgv );
+#elif defined OS2
+    nRet = _spawnv( P_WAIT, ppArgv[0], ppArgv );
+#elif defined UNX
+    //fprintf( stderr, "CComand : operator (int) not implemented\n");
+    // **** Unix Implementierung ***************
+    pid_t pid;
+
+    if (( pid = fork()) < 0 )
+    {
+        DBG_ASSERT( sal_False, "fork error" );
+    }
+    else if ( pid == 0 )
+    {
+        if ( execv( ppArgv[0], (char * const *) ppArgv ) < 0 )
+        {
+            DBG_ASSERT( sal_False, "execv failed" );
+        }
+    }
+    //fprintf( stderr, "parent: %s %s\n", ppArgv[0] , ppArgv[1] );
+    if ( (nRet = waitpid( pid, NULL, 0 ) < 0) )
+    {
+        DBG_ASSERT( sal_False, "wait error" );
+    }
+#endif
+
+    switch ( errno )
+    {
+        case    E2BIG :
+                    nError = COMMAND_TOOBIG;
+                    break;
+        case    EINVAL :
+                    nError = COMMAND_INVALID;
+                    break;
+        case    ENOENT:
+                    nError = COMMAND_NOTFOUND;
+                    break;
+        case    ENOEXEC :
+                    nError = COMMAND_NOEXEC;
+                    break;
+        case    ENOMEM :
+                    nError = COMMAND_NOMEM;
+                    break;
+        default:
+                nError = COMMAND_UNKNOWN;
+    }
+
+    if ( nRet )
+        fprintf( stderr, "Program returned with errros\n");
+    return nRet;
+}
+
+/*****************************************************************************/
+ByteString CCommand::Search(ByteString aEnv, ByteString sItem)
+/*****************************************************************************/
+{
+    // default wird eine Shell im Path gesucht,
+    // wenn aber compsec gestzt ist holen wir uns die
+    // Shell von dort
+    if ( sItem.Equals( COMMAND_SHELL ))
+    {
+        ByteString aComspec = GetEnv( "COMSPEC" );
+        if ( !aComspec.Equals(""))
+            return aComspec;
+    }
+
+    DirEntry aItem( String( sItem, RTL_TEXTENCODING_ASCII_US ));
+    if ( aItem.Exists())
+        return sItem;
+
+    ByteString aEntry, sReturn;
+    ByteString sEnv( aEnv );
+    ByteString sEnvironment = GetEnv( sEnv.GetBuffer());
+    xub_StrLen nCount = sEnvironment.GetTokenCount( cPathSeperator );
+
+    sal_Bool bFound = sal_False;
+
+    for ( xub_StrLen i=0; i<nCount && !bFound; i++ )
+    {
+        aEntry = sEnvironment.GetToken(i, cPathSeperator );
+#ifndef UNX
+        aEntry += '\\';
+#else
+        aEntry += '/';
+#endif
+        aEntry += sItem;
+
+        String sEntry( aEntry, RTL_TEXTENCODING_ASCII_US );
+        DirEntry aDirEntry( sEntry );
+        aDirEntry.ToAbs();
+        if ( aDirEntry.Exists()) {
+            sReturn = aEntry;
+            bFound = sal_True;
+        }
+    }
+    if ( !bFound )
+    {
+        sEnv = sEnv.ToUpperAscii();
+        ByteString sEnvironment2 = GetEnv(sEnv.GetBuffer() );
+        xub_StrLen nCount2 = sEnvironment2.GetTokenCount( cPathSeperator );
+        for ( xub_StrLen i=0; i<nCount2 && !bFound; i++ )
+        {
+            aEntry = sEnvironment2.GetToken(i, cPathSeperator );
+#ifndef UNX
+            aEntry += '\\';
+#else
+            aEntry += '/';
+#endif
+            aEntry += sItem;
+
+            String sEntry( aEntry, RTL_TEXTENCODING_ASCII_US );
+            DirEntry aDirEntry( sEntry );
+            aDirEntry.ToAbs();
+            if ( aDirEntry.Exists()) {
+                sReturn = aEntry;
+                bFound = sal_True;
+            }
+        }
+    }
+
+    if ( sReturn.Equals( "" ))
+        sReturn = sItem;
+
+    return sReturn;
+}
+
+/*****************************************************************************/
+CCommandd::CCommandd( ByteString &rString, CommandBits nBits )
+/*****************************************************************************/
+                : CCommand( rString ),
+                nFlag( nBits )
+{
+}
+
+
+/*****************************************************************************/
+CCommandd::CCommandd( const char *pChar, CommandBits nBits )
+/*****************************************************************************/
+                : CCommand( pChar ),
+                nFlag( nBits )
+{
+}
+
+/*****************************************************************************/
+CCommandd::operator int()
+/*****************************************************************************/
+{
+    int nRet = 0;
+
+#ifdef WNT
+    LPCTSTR lpApplicationName = NULL;
+    LPTSTR lpCommandLine = (char *) GetCommandLine_().GetBuffer();
+    LPSECURITY_ATTRIBUTES lpProcessAttributes = NULL;
+    LPSECURITY_ATTRIBUTES lpThreadAttributes = NULL;
+    sal_Bool bInheritHandles = sal_True;
+
+    // wie wuenschen wir denn gestartet zu werden ??
+    DWORD dwCreationFlags;
+
+    if ( nFlag & COMMAND_EXECUTE_START )
+        dwCreationFlags = DETACHED_PROCESS;
+    else
+        dwCreationFlags = CREATE_NEW_CONSOLE;
+
+    // wir erben vom Vaterprozess
+    LPVOID lpEnvironment = NULL;
+
+    // das exe im Pfad suchen
+    LPCTSTR lpCurrentDirectory = NULL;
+
+    // in dieser Struktur bekommen wir die erzeugte Processinfo
+    // zurueck
+    PROCESS_INFORMATION aProcessInformation;
+
+    // weiteres Startupinfo anlegen
+    STARTUPINFO aStartupInfo;
+
+    aStartupInfo.cb = sizeof( STARTUPINFO );
+    aStartupInfo.lpReserved = NULL;
+    aStartupInfo.lpDesktop = NULL;
+
+    // das Fenster bekommt den Namen des Exes
+    aStartupInfo.lpTitle = NULL;
+    aStartupInfo.dwX = 100;
+    aStartupInfo.dwY = 100;
+    //aStartupInfo.dwXSize = 400;
+    //aStartupInfo.dwYSize = 400;
+    aStartupInfo.dwXCountChars = 40;
+    aStartupInfo.dwYCountChars = 40;
+
+    // Farben setzen
+    aStartupInfo.dwFillAttribute = FOREGROUND_RED | BACKGROUND_RED |
+                                BACKGROUND_BLUE | BACKGROUND_GREEN;
+
+//  aStartupInfo.dwFlags = STARTF_USESTDHANDLES;
+    //aStartupInfo.wShowWindow = SW_NORMAL; //SW_SHOWDEFAULT;
+    //aStartupInfo.wShowWindow = SW_HIDE; //SW_SHOWNOACTIVATE;
+    aStartupInfo.wShowWindow = SW_SHOWNOACTIVATE;
+    aStartupInfo.cbReserved2 = NULL;
+    aStartupInfo.lpReserved2 = NULL;
+    //aStartupInfo.hStdInput = stdin;
+    //aStartupInfo.hStdOutput = stdout;
+    //aStartupInfo.hStdError = stderr;
+
+    if ( nFlag & COMMAND_EXECUTE_HIDDEN )
+    {
+        aStartupInfo.wShowWindow = SW_HIDE;
+        aStartupInfo.dwFlags = aStartupInfo.dwFlags | STARTF_USESHOWWINDOW;
+    }
+
+    bool bProcess = CreateProcess( lpApplicationName,
+                        lpCommandLine, lpProcessAttributes,
+                        lpThreadAttributes, bInheritHandles,
+                        dwCreationFlags, lpEnvironment, lpCurrentDirectory,
+                        &aStartupInfo, &aProcessInformation );
+
+    LPVOID lpMsgBuf;
+
+    if ( bProcess )
+    {
+        FormatMessage(
+                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+                NULL,
+                GetLastError(),
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+                (LPTSTR) &lpMsgBuf,
+                0,
+                NULL );
+
+        ByteString aErrorString = (char *) lpMsgBuf;
+
+        if ( nFlag & COMMAND_EXECUTE_WAIT )
+        {
+            DWORD aProcessState = STILL_ACTIVE;
+            while(aProcessState == STILL_ACTIVE)
+            {
+                GetExitCodeProcess(aProcessInformation.hProcess,&aProcessState);
+            }
+        }
+    }
+    else
+        fprintf( stderr, "Can not start Process !" );
+
+#endif
+    return nRet;
+}
diff --git a/soldep/bootstrp/makefile.mk b/soldep/bootstrp/makefile.mk
index 56d3fa1f07f4..b27f79734673 100644
--- a/soldep/bootstrp/makefile.mk
+++ b/soldep/bootstrp/makefile.mk
@@ -47,11 +47,13 @@ EXCEPTIONSFILES= \
                   $(SLO)$/prj.obj
 
 SLOFILES=\
+          $(SLO)$/command.obj \
           $(SLO)$/dep.obj \
           $(SLO)$/minormk.obj \
           $(SLO)$/prodmap.obj \
           $(SLO)$/appdef.obj \
            $(SLO)$/hashtbl.obj		\
+           $(SLO)$/sstring.obj		\
           $(SLO)$/prj.obj
 
 
@@ -62,7 +64,6 @@ SHL1DEF		=$(MISC)$/$(SHL1TARGET).def
 SHL1DEPN	=$(SHL1LIBS)
 SHL1STDLIBS=\
             $(TOOLSLIB) \
-            $(BTSTRPLIB)		\
             $(VOSLIB)			\
             $(SALLIB)   
 
diff --git a/soldep/bootstrp/minormk.cxx b/soldep/bootstrp/minormk.cxx
index 8c08d3a69840..acd8478cf11a 100644
--- a/soldep/bootstrp/minormk.cxx
+++ b/soldep/bootstrp/minormk.cxx
@@ -27,7 +27,7 @@
 
 #include "minormk.hxx"
 #include "prodmap.hxx"
-#include <appdef.hxx>
+#include <soldep/appdef.hxx>
 #include <tools/fsys.hxx>
 #include <tools/geninfo.hxx>
 
diff --git a/soldep/bootstrp/prj.cxx b/soldep/bootstrp/prj.cxx
index 36495a429de8..746fa091e4b6 100644
--- a/soldep/bootstrp/prj.cxx
+++ b/soldep/bootstrp/prj.cxx
@@ -26,14 +26,14 @@
  ************************************************************************/
 #include <stdlib.h>
 #include <stdio.h>
-#include <bootstrp/sstring.hxx>
+#include <soldep/sstring.hxx>
 #include <vos/mutex.hxx>
 
 #define ENABLE_BYTESTRING_STREAM_OPERATORS
 #include <tools/stream.hxx>
 #include <tools/geninfo.hxx>
 #include <soldep/prj.hxx>
-#include <bootstrp/inimgr.hxx>
+//#include <bootstrp/inimgr.hxx>
 
 #ifndef MACOSX
 #pragma hdrstop
@@ -1212,24 +1212,21 @@ Star::Star(SolarFileList *pSolarFiles )
 }
 
 /*****************************************************************************/
-Star::Star(GenericInformationList *pStandLst, ByteString &rVersion,
-    BOOL bLocal, const char *pSourceRoot )
+Star::Star(GenericInformationList *pStandLst, ByteString &rVersion )
 /*****************************************************************************/
                 : pDepMode (NULL),
                 pAllDepMode (NULL)
 {
-    UpdateFileList (pStandLst, rVersion, TRUE, bLocal, pSourceRoot);
+    UpdateFileList (pStandLst, rVersion, TRUE );
 }
 
 /*****************************************************************************/
 void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion,
-    BOOL bRead, BOOL bLocal, const char *pSourceRoot )
+    BOOL bRead )
 /*****************************************************************************/
 {
     sSourceRoot=String::CreateFromAscii(""); // clear old SourceRoot
     ByteString sPath( rVersion );
-    if ( pSourceRoot )
-        sSourceRoot = String::CreateFromAscii( pSourceRoot );
 
 #ifdef UNX
     sPath += "/settings/UNXSOLARLIST";
@@ -1240,10 +1237,6 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
 
     if( pInfo && pInfo->GetValue().Len()) {
         ByteString sFile( pInfo->GetValue());
-        if ( bLocal ) {
-            IniManager aIniManager;
-            aIniManager.ToLocal( sFile );
-        }
         String sFileName_l( sFile, RTL_TEXTENCODING_ASCII_US );
         nStarMode = STAR_MODE_SINGLE_PARSE;
         if (bRead)
@@ -1360,14 +1353,14 @@ void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersi
 
 /*****************************************************************************/
 void Star::FullReload( GenericInformationList *pStandLst, ByteString &rVersion,
-    BOOL bRead, BOOL bLocal, const char *pSourceRoot )
+    BOOL bRead )
 /*****************************************************************************/
 {
     ClearAvailableDeps();
     ClearCurrentDeps();
     ClearLoadedFilesList();
     RemoveAllPrj();
-    UpdateFileList( pStandLst, rVersion, bRead, bLocal, pSourceRoot );
+    UpdateFileList( pStandLst, rVersion, bRead );
 }
 
 /*****************************************************************************/
@@ -2419,13 +2412,11 @@ StarWriter::StarWriter( SolarFileList *pSolarFiles, BOOL bReadComments )
 
 /*****************************************************************************/
 StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
-    ByteString &rMinor, BOOL bReadComments, BOOL bLocal, const char *pSourceRoot )
+    ByteString &rMinor, BOOL bReadComments )
 /*****************************************************************************/
                 : Star ()
 {
     ByteString sPath( rVersion );
-    if ( pSourceRoot )
-        sSourceRoot = String::CreateFromAscii( pSourceRoot );
 
 #ifdef UNX
     sPath += "/settings/UNXSOLARLIST";
@@ -2436,10 +2427,6 @@ StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
 
     if( pInfo_l && pInfo_l->GetValue().Len()) {
         ByteString sFile( pInfo_l->GetValue());
-        if ( bLocal ) {
-            IniManager aIniManager;
-            aIniManager.ToLocal( sFile );
-        }
         String sFileName_l( sFile, RTL_TEXTENCODING_ASCII_US );
         nStarMode = STAR_MODE_SINGLE_PARSE;
         Read( sFileName_l, bReadComments );
diff --git a/soldep/bootstrp/sstring.cxx b/soldep/bootstrp/sstring.cxx
new file mode 100644
index 000000000000..a9c50839f6f6
--- /dev/null
+++ b/soldep/bootstrp/sstring.cxx
@@ -0,0 +1,314 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _TOOLS_STRINGLIST
+#  define _TOOLS_STRINGLIST
+#endif
+
+#define ENABLE_BYTESTRING_STREAM_OPERATORS
+#include <tools/stream.hxx>
+#include "soldep/sstring.hxx"
+
+SByteStringList::SByteStringList()
+{
+}
+
+SByteStringList::~SByteStringList()
+{
+}
+
+sal_uIntPtr SByteStringList::IsString( ByteString* pStr )
+{
+    sal_uIntPtr nRet = NOT_THERE;
+    if ( (nRet = GetPrevString( pStr )) != 0 )
+    {
+        ByteString* pString = GetObject( nRet );
+        if ( *pString == *pStr )
+            return nRet;
+        else
+            return NOT_THERE;
+    }
+    else
+    {
+        ByteString* pString = GetObject( 0 );
+        if ( pString && (*pString == *pStr) )
+            return 0;
+        else
+            return NOT_THERE;
+    }
+}
+
+sal_uIntPtr SByteStringList::GetPrevString( ByteString* pStr )
+{
+    sal_uIntPtr nRet = 0;
+    sal_Bool bFound = sal_False;
+    sal_uIntPtr nCountMember = Count();
+    sal_uIntPtr nUpper = nCountMember;
+    sal_uIntPtr nLower = 0;
+    sal_uIntPtr nCurrent = nUpper / 2;
+    sal_uIntPtr nRem = 0;
+    ByteString* pString;
+
+    do
+    {
+        if ( (nCurrent == nLower) || (nCurrent == nUpper) )
+            return nLower;
+        pString = GetObject( nCurrent );
+        StringCompare nResult =  pStr->CompareTo( *pString );
+        if ( nResult == COMPARE_LESS )
+        {
+            nUpper = nCurrent;
+            nCurrent = (nCurrent + nLower) /2;
+        }
+        else if ( nResult == COMPARE_GREATER )
+        {
+            nLower = nCurrent;
+            nCurrent = (nUpper + nCurrent) /2;
+        }
+        else if ( nResult == COMPARE_EQUAL )
+            return nCurrent;
+        if ( nRem == nCurrent )
+            return nCurrent;
+        nRem = nCurrent;
+    }
+    while ( !bFound );
+    return nRet;
+}
+
+/**************************************************************************
+*
+*   Sortiert einen ByteString in die Liste ein und gibt die Position,
+*   an der einsortiert wurde, zurueck
+*
+**************************************************************************/
+
+sal_uIntPtr SByteStringList::PutString( ByteString* pStr )
+{
+    sal_uIntPtr nPos = GetPrevString ( pStr );
+    if ( Count() )
+    {
+        {
+            ByteString* pString = GetObject( 0 );
+            if ( pString->CompareTo( *pStr ) == COMPARE_GREATER )
+            {
+                Insert( pStr, (sal_uIntPtr)0 );
+                return (sal_uIntPtr)0;
+            }
+        }
+        ByteString* pString = GetObject( nPos );
+        if ( *pStr != *pString )
+        {
+            Insert( pStr, nPos+1 );
+            return ( nPos +1 );
+        }
+    }
+    else
+    {
+        Insert( pStr );
+        return (sal_uIntPtr)0;
+    }
+
+    return NOT_THERE;
+}
+
+ByteString* SByteStringList::RemoveString( const ByteString& rName )
+{
+    sal_uIntPtr i;
+    ByteString* pReturn;
+
+    for( i = 0 ; i < Count(); i++ )
+    {
+        if ( rName == *GetObject( i ) )
+        {
+            pReturn = GetObject(i);
+            Remove(i);
+            return pReturn;
+        }
+    }
+
+    return NULL;
+}
+
+void SByteStringList::CleanUp()
+{
+    ByteString* pByteString = First();
+    while (pByteString) {
+        delete pByteString;
+        pByteString = Next();
+    }
+    Clear();
+}
+
+SByteStringList& SByteStringList::operator<<  ( SvStream& rStream )
+{
+    sal_uInt32 nListCount;
+    rStream >> nListCount;
+    for ( sal_uInt16 i = 0; i < nListCount; i++ ) {
+        ByteString* pByteString = new ByteString();
+        rStream >> *pByteString;
+        Insert (pByteString, LIST_APPEND);
+    }
+    return *this;
+}
+
+SByteStringList& SByteStringList::operator>>  ( SvStream& rStream )
+{
+    sal_uInt32 nListCount = Count();
+    rStream << nListCount;
+    ByteString* pByteString = First();
+    while (pByteString) {
+        rStream << *pByteString;
+        pByteString = Next();
+    }
+    return *this;
+}
+
+
+
+
+
+
+
+SUniStringList::SUniStringList()
+{
+}
+
+SUniStringList::~SUniStringList()
+{
+}
+
+sal_uIntPtr SUniStringList::IsString( UniString* pStr )
+{
+    sal_uIntPtr nRet = NOT_THERE;
+    if ( (nRet = GetPrevString( pStr )) != 0 )
+    {
+        UniString* pString = GetObject( nRet );
+        if ( *pString == *pStr )
+            return nRet;
+        else
+            return NOT_THERE;
+    }
+    else
+    {
+        UniString* pString = GetObject( 0 );
+        if ( pString && (*pString == *pStr) )
+            return 0;
+        else
+            return NOT_THERE;
+    }
+}
+
+sal_uIntPtr SUniStringList::GetPrevString( UniString* pStr )
+{
+    sal_uIntPtr nRet = 0;
+    sal_Bool bFound = sal_False;
+    sal_uIntPtr nCountMember = Count();
+    sal_uIntPtr nUpper = nCountMember;
+    sal_uIntPtr nLower = 0;
+    sal_uIntPtr nCurrent = nUpper / 2;
+    sal_uIntPtr nRem = 0;
+    UniString* pString;
+
+    do
+    {
+        if ( (nCurrent == nLower) || (nCurrent == nUpper) )
+            return nLower;
+        pString = GetObject( nCurrent );
+        StringCompare nResult =  pStr->CompareTo( *pString );
+        if ( nResult == COMPARE_LESS )
+        {
+            nUpper = nCurrent;
+            nCurrent = (nCurrent + nLower) /2;
+        }
+        else if ( nResult == COMPARE_GREATER )
+        {
+            nLower = nCurrent;
+            nCurrent = (nUpper + nCurrent) /2;
+        }
+        else if ( nResult == COMPARE_EQUAL )
+            return nCurrent;
+        if ( nRem == nCurrent )
+            return nCurrent;
+        nRem = nCurrent;
+    }
+    while ( !bFound );
+    return nRet;
+}
+
+/**************************************************************************
+*
+*   Sortiert einen UniString in die Liste ein und gibt die Position,
+*   an der einsortiert wurde, zurueck
+*
+**************************************************************************/
+
+sal_uIntPtr SUniStringList::PutString( UniString* pStr )
+{
+    sal_uIntPtr nPos = GetPrevString ( pStr );
+    if ( Count() )
+    {
+        {
+            UniString* pString = GetObject( 0 );
+            if ( pString->CompareTo( *pStr ) == COMPARE_GREATER )
+            {
+                Insert( pStr, (sal_uIntPtr)0);
+                return (sal_uIntPtr)0;
+            }
+        }
+        UniString* pString = GetObject( nPos );
+        if ( *pStr != *pString )
+        {
+            Insert( pStr, nPos+1 );
+            return ( nPos +1 );
+        }
+    }
+    else
+    {
+        Insert( pStr );
+        return (sal_uIntPtr)0;
+    }
+
+    return NOT_THERE;
+}
+
+UniString* SUniStringList::RemoveString( const UniString& rName )
+{
+    sal_uIntPtr i;
+    UniString* pReturn;
+
+    for( i = 0 ; i < Count(); i++ )
+    {
+        if ( rName == *GetObject( i ) )
+        {
+            pReturn = GetObject(i);
+            Remove(i);
+            return pReturn;
+        }
+    }
+
+    return NULL;
+}