rebase to DEV300_m96

19 files changed, 1353 insertions, 48 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..10964fd69d2f
--- /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(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, 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, 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(' ');
+    ULONG nLen = aCommandLine.Len();
+
+    ppArgv = (char **) new char[ (ULONG)(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 )
+        {
+            USHORT 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( FALSE, "fork error" );
+    }
+    else if ( pid == 0 )
+    {
+        if ( execv( ppArgv[0], (char * const *) ppArgv ) < 0 )
+        {
+            DBG_ASSERT( FALSE, "execv failed" );
+        }
+    }
+    //fprintf( stderr, "parent: %s %s\n", ppArgv[0] , ppArgv[1] );
+    if ( (nRet = waitpid( pid, NULL, 0 ) < 0) )
+    {
+        DBG_ASSERT( 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 );
+
+    BOOL bFound = 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 = 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 = 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;
+    BOOL bInheritHandles = 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..a08594015759
--- /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()
+{
+}
+
+ULONG SByteStringList::IsString( ByteString* pStr )
+{
+    ULONG 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;
+    }
+}
+
+ULONG SByteStringList::GetPrevString( ByteString* pStr )
+{
+    ULONG nRet = 0;
+    BOOL bFound = FALSE;
+    ULONG nCountMember = Count();
+    ULONG nUpper = nCountMember;
+    ULONG nLower = 0;
+    ULONG nCurrent = nUpper / 2;
+    ULONG 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
+*
+**************************************************************************/
+
+ULONG SByteStringList::PutString( ByteString* pStr )
+{
+    ULONG nPos = GetPrevString ( pStr );
+    if ( Count() )
+    {
+        {
+            ByteString* pString = GetObject( 0 );
+            if ( pString->CompareTo( *pStr ) == COMPARE_GREATER )
+            {
+                Insert( pStr, (ULONG)0 );
+                return (ULONG)0;
+            }
+        }
+        ByteString* pString = GetObject( nPos );
+        if ( *pStr != *pString )
+        {
+            Insert( pStr, nPos+1 );
+            return ( nPos +1 );
+        }
+    }
+    else
+    {
+        Insert( pStr );
+        return (ULONG)0;
+    }
+
+    return NOT_THERE;
+}
+
+ByteString* SByteStringList::RemoveString( const ByteString& rName )
+{
+    ULONG 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 ( USHORT 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()
+{
+}
+
+ULONG SUniStringList::IsString( UniString* pStr )
+{
+    ULONG 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;
+    }
+}
+
+ULONG SUniStringList::GetPrevString( UniString* pStr )
+{
+    ULONG nRet = 0;
+    BOOL bFound = FALSE;
+    ULONG nCountMember = Count();
+    ULONG nUpper = nCountMember;
+    ULONG nLower = 0;
+    ULONG nCurrent = nUpper / 2;
+    ULONG 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
+*
+**************************************************************************/
+
+ULONG SUniStringList::PutString( UniString* pStr )
+{
+    ULONG nPos = GetPrevString ( pStr );
+    if ( Count() )
+    {
+        {
+            UniString* pString = GetObject( 0 );
+            if ( pString->CompareTo( *pStr ) == COMPARE_GREATER )
+            {
+                Insert( pStr, (ULONG)0);
+                return (ULONG)0;
+            }
+        }
+        UniString* pString = GetObject( nPos );
+        if ( *pStr != *pString )
+        {
+            Insert( pStr, nPos+1 );
+            return ( nPos +1 );
+        }
+    }
+    else
+    {
+        Insert( pStr );
+        return (ULONG)0;
+    }
+
+    return NOT_THERE;
+}
+
+UniString* SUniStringList::RemoveString( const UniString& rName )
+{
+    ULONG i;
+    UniString* pReturn;
+
+    for( i = 0 ; i < Count(); i++ )
+    {
+        if ( rName == *GetObject( i ) )
+        {
+            pReturn = GetObject(i);
+            Remove(i);
+            return pReturn;
+        }
+    }
+
+    return NULL;
+}
diff --git a/soldep/inc/dep.hxx b/soldep/inc/dep.hxx
index f7ef15ace882..4e7d4b80ec3e 100644
--- a/soldep/inc/dep.hxx
+++ b/soldep/inc/dep.hxx
@@ -28,7 +28,7 @@
 #ifndef _DEP_HXX
 #define _DEP_HXX
 
-#include <bootstrp/sstring.hxx>
+#include <soldep/sstring.hxx>
 
 class SByteExtStringList : public SByteStringList
 {
diff --git a/soldep/inc/prodmap.hxx b/soldep/inc/prodmap.hxx
index 97b554b9e52d..ac39b97b5bc3 100644
--- a/soldep/inc/prodmap.hxx
+++ b/soldep/inc/prodmap.hxx
@@ -28,9 +28,7 @@
 #ifndef PRODUCT_MAPPER_HXX
 #define PRODUCT_MAPPER_HXX
 
-#ifndef _SSTRING_HXX
-#include <bootstrp/sstring.hxx>
-#endif
+#include <soldep/sstring.hxx>
 
 class GenericInformation;
 class GenericInformationList;
diff --git a/soldep/inc/appdef.hxx b/soldep/inc/soldep/appdef.hxx
index cc8d5d0f2f8b..cc8d5d0f2f8b 100644
--- a/soldep/inc/appdef.hxx
+++ b/soldep/inc/soldep/appdef.hxx
diff --git a/soldep/inc/soldep/command.hxx b/soldep/inc/soldep/command.hxx
new file mode 100644
index 000000000000..638beb6cce1f
--- /dev/null
+++ b/soldep/inc/soldep/command.hxx
@@ -0,0 +1,163 @@
+/*************************************************************************
+ *
+ * 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 COMMAND_HXX
+#define COMMAND_HXX
+
+#include <iostream>
+
+#include <tools/stream.hxx>
+#define STRLEN 100
+#ifndef UNX
+#define TMPNAME "\\command.tmp"
+#else
+#define TMPNAME "/tmp/command.tmp"
+#endif
+
+/** Different types of spawnable programs
+*/
+enum ExeType
+{
+    EXE,    /// programm is a native executable
+    BAT,    /// programm is a DOS-Batch
+    BTM     /// programm is a 4DOS-Batch
+};
+
+#define COMMAND_NOTFOUND    0x0001
+#define COMMAND_TOOBIG      0x0002
+#define COMMAND_INVALID     0x0004
+#define COMMAND_NOEXEC      0x0008
+#define COMMAND_NOMEM       0x0010
+#define COMMAND_UNKNOWN     0x0020
+
+#ifdef WNT
+#define COMMAND_SHELL   "4nt.exe"
+#endif
+#ifdef OS2
+#define COMMAND_SHELL  "4os2.exe"
+#endif
+#ifdef UNX
+#define COMMAND_SHELL   "csh"
+#endif
+
+class CommandLine;
+class LogWindow;
+
+class CommandLine
+{
+friend class ChildProcess;
+private:
+    char            *CommandBuffer;
+    char            *ComShell;
+    char            **ppArgv;
+    BOOL            bTmpWrite;
+
+public:
+                    CommandLine(BOOL bTmpWrite = FALSE);
+                    CommandLine(const char *, BOOL bTmpWrite = FALSE);
+                    CommandLine(const CommandLine&, BOOL bTmpWrite = FALSE);
+    virtual         ~CommandLine();
+
+    int             nArgc;
+
+    CommandLine&    operator=(const CommandLine&);
+    CommandLine&    operator=(const char *);
+    void            BuildCommand(const char *);
+    char**          GetCommand(void) { return ppArgv; }
+    void            Strtokens(const char *);
+    void            Print();
+};
+
+/** Declares and spawns a child process.
+    The spawned programm could be a native executable or a schell script.
+*/
+class CCommand
+{
+private:
+    ByteString          aCommandLine;
+    ByteString          aCommand;
+    char                *pArgv;
+    char                **ppArgv;
+    ULONG               nArgc;
+    int                 nError;
+
+protected:
+    void            ImplInit();
+    void            Initpp( ULONG nCount, ByteString &rStr );
+
+public:
+                    /** Creates the process specified without spawning it
+                        @param rString specifies the programm or shell scrip
+                    */
+                    CCommand( ByteString &rString );
+
+                    /** Creates the process specified without spawning it
+                        @param pChar specifies the programm or shell scrip
+                    */
+                    CCommand( const char *pChar );
+
+                    /** Try to find the given programm in specified path
+                        @param sEnv specifies the current search path, defaulted by environment
+                        @param sItem specifies the system shell
+                        @return the Location (when programm was found)
+                    */
+    static ByteString   Search( ByteString sEnv,
+                                    ByteString sItem = COMMAND_SHELL );
+
+                    /** Spawns the Process
+                        @return 0 when spawned without errors, otherwise a error code
+                    */
+    operator int();
+
+    ByteString          GetCommandLine_() { return aCommandLine; }
+    ByteString          GetCommand() { return aCommand; }
+
+    char**  GetCommandStr() { return ppArgv; }
+};
+
+#define COMMAND_EXECUTE_WINDOW  0x0000001
+#define COMMAND_EXECUTE_CONSOLE 0x0000002
+#define COMMAND_EXECUTE_HIDDEN  0x0000004
+#define COMMAND_EXECUTE_START   0x0000008
+#define COMMAND_EXECUTE_WAIT    0x0000010
+#define COMMAND_EXECUTE_REMOTE  0x1000000
+
+typedef ULONG CommandBits;
+
+/** Allowes to spawn programms hidden, waiting etc.
+    @see CCommand
+*/
+class CCommandd : public CCommand
+{
+    CommandBits     nFlag;
+public:
+                    CCommandd( ByteString &rString, CommandBits nBits );
+                    CCommandd( const char *pChar, CommandBits nBits );
+    operator int();
+};
+
+#endif
diff --git a/soldep/inc/soldep/connctr.hxx b/soldep/inc/soldep/connctr.hxx
index 40ef986245e5..1982e252acf8 100644
--- a/soldep/inc/soldep/connctr.hxx
+++ b/soldep/inc/soldep/connctr.hxx
@@ -30,10 +30,8 @@
 #define _FMRWRK_CONNCTR_HXX
 
 
-#ifndef _SV_WINDOW_HXX
 #include <vcl/window.hxx>
-#endif
-#include <bootstrp/listmacr.hxx>
+#include <soldep/listmacr.hxx>
 #include <tools/stream.hxx>
 
 class DepWin;
diff --git a/soldep/inc/soldep/listmacr.hxx b/soldep/inc/soldep/listmacr.hxx
new file mode 100644
index 000000000000..8c678ff32275
--- /dev/null
+++ b/soldep/inc/soldep/listmacr.hxx
@@ -0,0 +1,60 @@
+/*************************************************************************
+ *
+ * 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 _LISTMACR_HXX
+#define _LISTMACR_HXX
+
+#define DECL_DEST_LIST( TmpListType, ListType, PointerType )    \
+DECLARE_LIST(TmpListType, PointerType)                          \
+class ListType : public TmpListType                             \
+{                                                               \
+public:                                                         \
+    void ClearAndDelete()                                       \
+    {                                                           \
+        while ( Count()) {                                      \
+            PointerType pTmp = GetObject(( ULONG ) 0 );         \
+            delete pTmp;                                        \
+            Remove(( ULONG ) 0 );                               \
+        }                                                       \
+    }                                                           \
+    ~ListType()                                                 \
+    {                                                           \
+        ClearAndDelete();                                       \
+    }                                                           \
+};                                                              \
+
+#endif
+
+
+
+
+
+
+
+
+
+
diff --git a/soldep/inc/soldep/objwin.hxx b/soldep/inc/soldep/objwin.hxx
index e7bc94826858..b3170a76ce11 100644
--- a/soldep/inc/soldep/objwin.hxx
+++ b/soldep/inc/soldep/objwin.hxx
@@ -33,7 +33,7 @@
 #endif
 #include <vcl/menu.hxx>
 #include <vcl/timer.hxx>
-#include <bootstrp/listmacr.hxx>
+#include <soldep/listmacr.hxx>
 #include <tools/stream.hxx>
 
 #include <soldep/connctr.hxx>
diff --git a/soldep/inc/soldep/prj.hxx b/soldep/inc/soldep/prj.hxx
index e5582301a9e4..7a75c5a1c310 100644
--- a/soldep/inc/soldep/prj.hxx
+++ b/soldep/inc/soldep/prj.hxx
@@ -30,9 +30,7 @@
 
 #include <tools/fsys.hxx>
 #include <tools/stream.hxx>
-#ifndef _LISTMACR_HXX
-#include <bootstrp/listmacr.hxx>
-#endif
+#include <soldep/listmacr.hxx>
 #include <vos/mutex.hxx>
 #include <tools/string.hxx>
 
@@ -406,8 +404,7 @@ public:
                     Star();
                     Star( String aFileName, USHORT nMode = STAR_MODE_SINGLE_PARSE );
                     Star( SolarFileList *pSolarFiles );
-                    Star( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bLocal = FALSE,
-                        const char *pSourceRoot = NULL  );
+                    Star( GenericInformationList *pStandLst, ByteString &rVersion );
 
                     ~Star();
 
@@ -430,10 +427,8 @@ public:
     BOOL            NeedsUpdate();
     SolarFileList*  NeedsFilesForUpdate();
     void            ReplaceFileEntry( StarFileList *pStarFiles, StarFile* pFile );
-    void            UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE,
-                        BOOL bLocal = FALSE, const char *pSourceRoot = NULL  );
-    void            FullReload( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE,
-                        BOOL bLocal = FALSE, const char *pSourceRoot = NULL  );
+    void            UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE );
+    void            FullReload( GenericInformationList *pStandLst, ByteString &rVersion, BOOL bRead = FALSE );
     void            GenerateFileLoadList( SolarFileList *pSolarFiles );
     BOOL            CheckFileLoadList(SolarFileList *pSolarFiles);
 
@@ -465,7 +460,7 @@ public:
                     StarWriter( String aFileName, BOOL bReadComments = FALSE, USHORT nMode = STAR_MODE_SINGLE_PARSE );
                     StarWriter( SolarFileList *pSolarFiles, BOOL bReadComments = FALSE );
                     StarWriter( GenericInformationList *pStandLst, ByteString &rVersion, ByteString &rMinor,
-                        BOOL bReadComments = FALSE, BOOL bLocal = FALSE, const char *pSourceRoot = NULL );
+                        BOOL bReadComments = FALSE );
 
     void            CleanUp();
 
diff --git a/soldep/inc/soldep/sstring.hxx b/soldep/inc/soldep/sstring.hxx
new file mode 100644
index 000000000000..933770887e37
--- /dev/null
+++ b/soldep/inc/soldep/sstring.hxx
@@ -0,0 +1,105 @@
+/*************************************************************************
+ *
+ * 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 _SSTRING_HXX
+#define _SSTRING_HXX
+
+#include <tools/string.hxx>
+#include <tools/list.hxx>
+
+#define NOT_THERE       LIST_ENTRY_NOTFOUND
+
+#define  SStringList SUniStringList
+#define  StringList UniStringList
+
+DECLARE_LIST( ByteStringList, ByteString* )
+DECLARE_LIST( UniStringList, UniString* )
+
+class SvStream;
+
+// ---------------------
+// - class SStringList -
+// ---------------------
+
+class SByteStringList : public ByteStringList
+{
+public:
+                SByteStringList();
+                ~SByteStringList();
+
+                // neuen ByteString in Liste einfuegen
+    ULONG       PutString( ByteString* );
+    ByteString*     RemoveString( const ByteString& rName );
+
+                // Position des ByteString in Liste, wenn nicht enthalten, dann
+                // return = NOT_THERE
+    ULONG       IsString( ByteString* );
+
+                // Vorgaenger ermitteln ( auch wenn selbst noch nicht in
+                // Liste enthalten
+    ULONG       GetPrevString( ByteString* );
+    void        CleanUp();
+
+    SByteStringList& operator<<  ( SvStream& rStream );
+    SByteStringList& operator>>  ( SvStream& rStream );
+};
+
+// ---------------------
+// - class SUniStringList -
+// ---------------------
+
+class SUniStringList : public UniStringList
+{
+public:
+                SUniStringList();
+                ~SUniStringList();
+
+                // neuen UniString in Liste einfuegen
+    ULONG       PutString( UniString* );
+    UniString*  RemoveString( const UniString& rName );
+
+                // Position des UniString in Liste, wenn nicht enthalten, dann
+                // return = NOT_THERE
+    ULONG       IsString( UniString* );
+
+                // Vorgaenger ermitteln ( auch wenn selbst noch nicht in
+                // Liste enthalten
+    ULONG       GetPrevString( UniString* );
+};
+
+class Text
+{
+protected:
+    String      aString;
+
+public:
+                Text( char* pChar );
+                Text( String &rStr ) { aString = rStr; }
+    void        Stderr();
+};
+
+#endif
diff --git a/soldep/prj/d.lst b/soldep/prj/d.lst
index 73301a558e61..cfd605ed3388 100644
--- a/soldep/prj/d.lst
+++ b/soldep/prj/d.lst
@@ -27,8 +27,11 @@ mkdir: %COMMON_DEST%\res%_EXT%\img\additional
 ..\inc\soldep\prj.hxx %_DEST%\inc%_EXT%\soldep\prj.hxx
 ..\inc\dep.hxx %_DEST%\inc%_EXT%\soldep\dep.hxx
 ..\inc\prodmap.hxx %_DEST%\inc%_EXT%\soldep\prodmap.hxx
-..\inc\appdef.hxx %_DEST%\inc%_EXT%\soldep\appdef.hxx
+..\inc\soldep\appdef.hxx %_DEST%\inc%_EXT%\soldep\appdef.hxx
 ..\inc\soldep\soldlg.hrc %_DEST%\inc%_EXT%\soldep\soldlg.hrc
+..\inc\soldep\sstring.hxx %_DEST%\inc%_EXT%\soldep\sstring.hxx
+..\inc\soldep\command.hxx %_DEST%\inc%_EXT%\soldep\command.hxx
+..\inc\soldep\listmacr.hxx %_DEST%\inc%_EXT%\soldep\listmacr.hxx
 
 ..\%__SRC%\lib\soldep.lib %_DEST%\lib%_EXT%\soldep.lib
 ..\%__SRC%\lib\bootstrpdt.lib %_DEST%\lib%_EXT%\bootstrpdt.lib
diff --git a/soldep/source/depapp.hxx b/soldep/source/depapp.hxx
index cf8c1935c220..e293ec7e1468 100644
--- a/soldep/source/depapp.hxx
+++ b/soldep/source/depapp.hxx
@@ -34,7 +34,7 @@
 
 #include <svl/solar.hrc>
 #include <tools/resmgr.hxx>
-#include <bootstrp/sstring.hxx>
+#include <soldep/sstring.hxx>
 #include <vcl/event.hxx>
 #include <vcl/svapp.hxx>
 #include <vcl/wrkwin.hxx>
diff --git a/soldep/source/makefile.mk b/soldep/source/makefile.mk
index 5f6b188a56d7..25cc78adeeba 100644
--- a/soldep/source/makefile.mk
+++ b/soldep/source/makefile.mk
@@ -68,7 +68,6 @@ SHL1STDLIBS     = $(SVTOOLLIB)		\
                 $(VCLLIB)			\
                 $(UCBHELPERLIB)	\
                 $(SOTLIB)			\
-                $(BTSTRPLIB)		\
                 $(TOOLSLIB) 		\
                 $(VOSLIB)			\
                 $(SALLIB)           \
@@ -109,7 +108,6 @@ APP1STDLIBS= \
             $(UCBHELPERLIB)	\
             $(VCLLIB)			\
             $(SOTLIB)			\
-            $(BTSTRPLIB)		\
             $(TOOLSLIB) 		\
             $(VOSLIB)			\
             $(SALLIB)           \
diff --git a/soldep/source/soldep.cxx b/soldep/source/soldep.cxx
index ce94afbbab92..3f4a6df3e9b7 100644
--- a/soldep/source/soldep.cxx
+++ b/soldep/source/soldep.cxx
@@ -29,13 +29,13 @@
 #include <osl/file.hxx>
 #include <rtl/ustring.hxx>
 #include <tools/debug.hxx>
-#include <bootstrp/sstring.hxx>
+#include <soldep/sstring.hxx>
 #include <svtools/filedlg.hxx>
 #include <tools/iparser.hxx>
 #include <tools/geninfo.hxx>
 #include <vcl/gdimtf.hxx>
 #include <vcl/bitmap.hxx>
-#include <appdef.hxx>
+#include <soldep/appdef.hxx>
 #include "time.h"
 #include <soldep/depper.hxx>
 #include <soldep/soldep.hxx>