initial import

6 files changed, 1609 insertions, 0 deletions

diff --git a/tools/workben/fstest.cxx b/tools/workben/fstest.cxx
new file mode 100644
index 000000000000..fc5b7a041a53
--- /dev/null
+++ b/tools/workben/fstest.cxx
@@ -0,0 +1,140 @@
+/*************************************************************************
+ *
+ *  $RCSfile: fstest.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:03:11 $
+ *
+ *  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 _FSTEST_CXX "$Revision: 1.1.1.1 $"
+
+#ifndef _SOLAR_H
+#include <solar.h>
+#endif
+
+#include <stdio.h>
+
+#ifndef _STREAM_HXX
+#include <stream.hxx>
+#endif
+
+#ifndef _FSYS_HXX
+#include <fsys.hxx>
+#endif
+
+#ifndef _DATE_HXX
+#include <date.hxx>
+#endif
+
+#ifndef _TIME_HXX
+#include <time.hxx>
+#endif
+
+void CheckTimes(DirEntry aDE);
+
+/*
+ * main.
+ */
+int main (int argc, char **argv)
+{
+    DirEntry aDir;
+    if (aDir.Exists())
+    {
+        aDir.ToAbs();
+        String sTmp(aDir.GetFull(FSYS_STYLE_HOST));
+        printf("Directory = %s\n", sTmp.GetStr());
+        CheckTimes(aDir);
+        DirEntry aFile =
+            aDir + DirEntry("testfile.txt", FSYS_STYLE_HOST);
+        SvFileStream aStream;
+        aStream.Open(aFile.GetFull(FSYS_STYLE_HOST), STREAM_WRITE);
+        aStream << "Test";
+        aStream.Close();
+        ULONG i, nWaitFor = 2000 + Time::GetSystemTicks();
+        for (i=Time::GetSystemTicks();
+                 i < nWaitFor;
+                 i = Time::GetSystemTicks())
+            ;
+        CheckTimes(aDir);
+        nWaitFor = 2000 + Time::GetSystemTicks();
+        for (i=Time::GetSystemTicks();
+                 i < nWaitFor;
+                 i = Time::GetSystemTicks())
+            ;
+        aFile.Kill();
+    }
+    else
+        puts("MakeDir failed!");
+    return 0;
+}
+
+void CheckTimes(DirEntry aDE)
+{
+    FileStat aDirStat(aDE);
+    aDirStat.Update(aDE);
+    Date aDateCreated(aDirStat.DateCreated());
+    Date aDateModified(aDirStat.DateModified());
+    Time aTimeCreated(aDirStat.TimeCreated());
+    Time aTimeModified(aDirStat.TimeModified());
+    printf(
+        "DirDateCreated = %i, DirTimeCreated = %i\n",
+        aDateCreated.GetDate(), aTimeCreated.GetTime());
+    printf(
+        "DirDateModified = %i, DirTimeModified = %i\n",
+        aDateModified.GetDate(), aTimeModified.GetTime());
+    return;
+}
+
diff --git a/tools/workben/hashtbl.cxx b/tools/workben/hashtbl.cxx
new file mode 100644
index 000000000000..73a5960bac28
--- /dev/null
+++ b/tools/workben/hashtbl.cxx
@@ -0,0 +1,544 @@
+/*************************************************************************
+ *
+ *  $RCSfile: hashtbl.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:03:11 $
+ *
+ *  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 <tlgen.hxx>
+#include "hashtbl.hxx"
+
+// -------------------------------------------------------------
+// class HashItem
+//
+class HashItem
+{
+    enum ETag { TAG_EMPTY, TAG_USED, TAG_DELETED };
+
+    void*   m_pObject;
+    ETag    m_Tag;
+    String  m_Key;
+
+public:
+    HashItem() { m_Tag = TAG_EMPTY; m_pObject = NULL; }
+
+    BOOL IsDeleted() const
+    {   return m_Tag == TAG_DELETED; }
+
+    BOOL IsEmpty() const
+    {   return m_Tag == TAG_DELETED || m_Tag == TAG_EMPTY; }
+
+    BOOL IsFree() const
+    {   return m_Tag == TAG_EMPTY; }
+
+    BOOL IsUsed() const
+    {   return m_Tag == TAG_USED; }
+
+    void Delete()
+    { m_Tag = TAG_DELETED; m_Key = ""; m_pObject = NULL; }
+
+    String const& GetKey() const
+    { return m_Key; }
+
+    void* GetObject() const
+    { return m_pObject; }
+
+    void SetObject(String const Key, void *pObject)
+    { m_Tag = TAG_USED; m_Key = Key; m_pObject = pObject; }
+};
+
+// #define MIN(a,b) (a)<(b)?(a):(b)
+// #define MAX(a,b) (a)>(b)?(a):(b)
+
+// -------------------------------------------------------------
+// class HashTable
+//
+
+/*static*/ double HashTable::m_defMaxLoadFactor = 0.8;
+/*static*/ double HashTable::m_defDefGrowFactor = 2.0;
+
+HashTable::HashTable(ULONG lSize, BOOL bOwner, double dMaxLoadFactor, double dGrowFactor)
+{
+    m_lSize          = lSize;
+    m_bOwner         = bOwner;
+    m_lElem          = 0;
+    m_dMaxLoadFactor = max(0.5,min(1.0,dMaxLoadFactor));  // 0.5 ... 1.0
+    m_dGrowFactor    = max(1.3,(5.0,dGrowFactor));     // 1.3 ... 5.0
+    m_pData          = new HashItem [lSize];
+
+// Statistik
+#ifdef DBG_UTIL
+    m_aStatistic.m_lSingleHash = 0;
+    m_aStatistic.m_lDoubleHash = 0;
+    m_aStatistic.m_lProbe      = 0;
+#endif
+}
+
+HashTable::~HashTable()
+{
+    // Wenn die HashTable der Owner der Objecte ist,
+    // m�ssen die Destruktoren separat gerufen werden.
+    // Dies geschieht �ber die virtuelle Methode OnDeleteObject()
+    //
+    // Problem: Virtuelle Funktionen sind im Destructor nicht virtuell!!
+    //          Der Code mu� deshalb ins Macro
+
+    /*
+    if (m_bOwner)
+    {
+        for (ULONG i=0; i<GetSize(); i++)
+        {
+            void *pObject = GetObjectAt(i);
+
+            if (pObject != NULL)
+                OnDeleteObject(pObject());
+        }
+    }
+    */
+
+    // Speicher f�r HashItems freigeben
+    delete [] m_pData;
+}
+
+void* HashTable::GetObjectAt(ULONG lPos) const
+// Gibt Objekt zur�ck, wenn es eines gibt, sonst NULL;
+{
+    DBG_ASSERT(lPos<m_lSize, "HashTable::GetObjectAt()");
+
+    HashItem *pItem = &m_pData[lPos];
+
+    return pItem->IsUsed() ? pItem->GetObject() : NULL;
+}
+
+void HashTable::OnDeleteObject(void*)
+{
+    DBG_ERROR("HashTable::OnDeleteObject(void*) nicht �berladen")
+}
+
+ULONG HashTable::Hash(String const& Key) const
+{
+    /*
+    ULONG lHash = 0;
+    ULONG i,n;
+
+    for (i=0,n=Key.Len(); i<n; i++)
+    {
+        lHash *= 256L;
+        lHash += (ULONG)(USHORT)Key.GetStr()[i];
+        lHash %= m_lSize;
+    }
+    return lHash;
+    */
+
+    // Hashfunktion von P.J. Weinberger
+    // aus dem "Drachenbuch" von Aho/Sethi/Ullman
+    ULONG i,n;
+    ULONG h = 0;
+    ULONG g = 0;
+
+    for (i=0,n=Key.Len(); i<n; i++)
+    {
+        h = (h<<4) + (ULONG)(USHORT)Key.GetStr()[i];
+        g = h & 0xf0000000;
+
+        if (g != 0)
+        {
+            h = h ^ (g >> 24);
+            h = h ^ g;
+        }
+    }
+
+    return h % m_lSize;
+}
+
+ULONG HashTable::DHash(String const& Key, ULONG lOldHash) const
+{
+    ULONG lHash = lOldHash;
+    ULONG i,n;
+
+    for (i=0,n=Key.Len(); i<n; i++)
+    {
+        lHash *= 256L;
+        lHash += (ULONG)(USHORT)Key.GetStr()[i];
+        lHash %= m_lSize;
+    }
+    return lHash;
+
+/*    return
+        (
+            lHash
+        +   (char)Key.GetStr()[0] * 256
+        +   (char)Key.GetStr()[Key.Len()-1]
+        +   1
+        )
+        % m_lSize;
+*/
+}
+
+ULONG HashTable::Probe(ULONG lPos) const
+// gibt den Folgewert von lPos zur�ck
+{
+    lPos++; if (lPos==m_lSize) lPos=0;
+    return lPos;
+}
+
+BOOL HashTable::IsFull() const
+{
+    return m_lElem>=m_lSize;
+}
+
+BOOL HashTable::Insert(String const& Key, void* pObject)
+// pre:  Key ist nicht im Dictionary enthalten, sonst return FALSE
+//       Dictionary ist nicht voll, sonst return FALSE
+// post: pObject ist unter Key im Dictionary; m_nElem wurde erh�ht
+{
+    SmartGrow();
+
+    if (IsFull())
+    {
+        DBG_ERROR("HashTable::Insert() is full");
+        return FALSE;
+    }
+
+    if (FindPos(Key) != NULL )
+        return FALSE;
+
+    ULONG     lPos  = Hash(Key);
+    HashItem *pItem = &m_pData[lPos];
+
+    // first hashing
+    //
+    if (pItem->IsEmpty())
+    {
+        pItem->SetObject(Key, pObject);
+        m_lElem++;
+
+        #ifdef DBG_UTIL
+        m_aStatistic.m_lSingleHash++;
+        #endif
+
+        return TRUE;
+    }
+
+    // double hashing
+    //
+    lPos  = DHash(Key,lPos);
+    pItem = &m_pData[lPos];
+
+    if (pItem->IsEmpty())
+    {
+        pItem->SetObject(Key, pObject);
+        m_lElem++;
+
+        #ifdef DBG_UTIL
+        m_aStatistic.m_lDoubleHash++;
+        #endif
+
+        return TRUE;
+    }
+
+    // linear probing
+    //
+    do
+    {
+        #ifdef DBG_UTIL
+        m_aStatistic.m_lProbe++;
+        #endif
+
+        lPos  = Probe(lPos);
+        pItem = &m_pData[lPos];
+    }
+    while(!pItem->IsEmpty());
+
+    pItem->SetObject(Key, pObject);
+    m_lElem++;
+    return TRUE;
+}
+
+HashItem* HashTable::FindPos(String const& Key) const
+// sucht den Key; gibt Refrenz auf den Eintrag (gefunden)
+// oder NULL (nicht gefunden) zur�ck
+//
+// pre:  -
+// post: -
+{
+    // first hashing
+    //
+    ULONG     lPos  = Hash(Key);
+    HashItem *pItem = &m_pData[lPos];
+
+    if (pItem->IsUsed()
+    &&  pItem->GetKey() == Key)
+    {
+        return pItem;
+    }
+
+    // double hashing
+    //
+    if (pItem->IsDeleted() || pItem->IsUsed())
+    {
+        lPos  = DHash(Key,lPos);
+        pItem = &m_pData[lPos];
+
+        if (pItem->IsUsed()
+        &&  pItem->GetKey() == Key)
+        {
+            return pItem;
+        }
+
+        // linear probing
+        //
+        if (pItem->IsDeleted() || pItem->IsUsed())
+        {
+            ULONG n      = 0;
+            BOOL  bFound = FALSE;
+            BOOL  bEnd   = FALSE;
+
+            do
+            {
+                n++;
+                lPos   = Probe(lPos);
+                pItem  = &m_pData[lPos];
+
+                bFound =  pItem->IsUsed()
+                       && pItem->GetKey() == Key;
+
+                bEnd = !(n<m_lSize || pItem->IsFree());
+            }
+            while(!bFound && !bEnd);
+
+            return bFound ? pItem : NULL;
+        }
+    }
+
+    // nicht gefunden
+    //
+    return NULL;
+}
+
+void* HashTable::Find(String const& Key) const
+// Gibt Verweis des Objektes zur�ck, das unter Key abgespeichert ist,
+// oder NULL wenn nicht vorhanden.
+//
+// pre:  -
+// post: -
+{
+    HashItem *pItem = FindPos(Key);
+
+    if (pItem != NULL
+    &&  pItem->GetKey() == Key)
+        return pItem->GetObject();
+    else
+        return NULL;
+}
+
+void* HashTable::Delete(String const& Key)
+// L�scht Objekt, das unter Key abgespeichert ist und gibt Verweis
+// darauf zur�ck.
+// Gibt NULL zur�ck, wenn Key nicht vorhanden ist.
+//
+// pre:  -
+// post: Objekt ist nicht mehr enthalten; m_lElem dekrementiert
+//       Wenn die HashTable der Owner ist, wurde das Object gel�scht
+{
+    HashItem *pItem = FindPos(Key);
+
+    if (pItem != NULL
+    &&  pItem->GetKey() == Key)
+    {
+        void* pObject = pItem->GetObject();
+
+        if (m_bOwner)
+            OnDeleteObject(pObject);
+
+        pItem->Delete();
+        m_lElem--;
+        return pObject;
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+double HashTable::CalcLoadFactor() const
+// prozentuale Belegung der Hashtabelle berechnen
+{
+    return double(m_lElem) / double(m_lSize);
+}
+
+void HashTable::SmartGrow()
+// Achtung: da die Objekte umkopiert werden, darf die OnDeleteObject-Methode
+//          nicht gerufen werden
+{
+    double dLoadFactor = CalcLoadFactor();
+
+    if (dLoadFactor <= m_dMaxLoadFactor)
+        return; // nothing to grow
+
+    ULONG     lOldSize = m_lSize;              // alte Daten sichern
+    HashItem* pOldData = m_pData;
+
+    m_lSize = ULONG (m_dGrowFactor * m_lSize); // neue Gr��e
+    m_pData = new HashItem[m_lSize];           // neue Daten holen
+
+    // kein Speicher:
+    // Zustand "Tabelle voll" wird in Insert abgefangen
+    //
+    if (m_pData == NULL)
+    {
+        m_lSize = lOldSize;
+        m_pData = pOldData;
+        return;
+    }
+
+    m_lElem = 0;                               // noch keine neuen Daten
+
+    // Umkopieren der Daten
+    //
+    for (ULONG i=0; i<lOldSize; i++)
+    {
+        HashItem *pItem = &pOldData[i];
+
+        if (pItem->IsUsed())
+            Insert(pItem->GetKey(),pItem->GetObject());
+    }
+
+    delete [] pOldData;
+}
+
+// Iterator ---------------------------------------------------------
+//
+
+HashTableIterator::HashTableIterator(HashTable const& aTable)
+: m_aTable(aTable)
+{
+    m_lAt = 0;
+}
+
+void* HashTableIterator::GetFirst()
+{
+    m_lAt = 0;
+    return FindValidObject(TRUE /* forward */);
+}
+
+void* HashTableIterator::GetLast()
+{
+    m_lAt = m_aTable.GetSize() -1;
+    return FindValidObject(FALSE /* backward */);
+}
+
+void* HashTableIterator::GetNext()
+{
+    if (m_lAt+1 >= m_aTable.GetSize())
+        return NULL;
+
+    m_lAt++;
+    return FindValidObject(TRUE /* forward */);
+}
+
+void* HashTableIterator::GetPrev()
+{
+    if (m_lAt <= 0)
+        return NULL;
+
+    m_lAt--;
+    return FindValidObject(FALSE /* backward */);
+}
+
+void* HashTableIterator::FindValidObject(BOOL bForward)
+// Sucht nach einem vorhandenen Objekt ab der aktuellen
+// Position.
+//
+// pre:  ab inkl. m_lAt soll die Suche beginnen
+// post: if not found then
+//          if bForward == TRUE then
+//              m_lAt == m_aTable.GetSize() -1
+//          else
+//              m_lAt == 0
+//       else
+//          m_lAt ist die gefundene Position
+{
+    void *pObject = m_aTable.GetObjectAt(m_lAt);
+
+    if (pObject != NULL)
+        return pObject;
+
+    while (pObject == NULL
+       && (bForward ? ((m_lAt+1) < m_aTable.GetSize())
+                    :   m_lAt    > 0))
+    {
+        if (bForward)
+            m_lAt++;
+        else
+            m_lAt--;
+
+        pObject = m_aTable.GetObjectAt(m_lAt);
+    }
+
+#ifdef DBG_UTIL
+
+    if (pObject == NULL)
+    {
+        DBG_ASSERT(bForward ? m_lAt == m_aTable.GetSize() -1 : m_lAt == 0,
+            "HashTableIterator::FindValidObject()");
+    }
+
+#endif
+
+    return pObject;
+}
diff --git a/tools/workben/hashtbl.hxx b/tools/workben/hashtbl.hxx
new file mode 100644
index 000000000000..224d9197d6dd
--- /dev/null
+++ b/tools/workben/hashtbl.hxx
@@ -0,0 +1,237 @@
+/*************************************************************************
+ *
+ *  $RCSfile: hashtbl.hxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:03:11 $
+ *
+ *  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 _HASHTBL_HXX
+#define _HASHTBL_HXX
+
+#include <tlgen.hxx>
+
+// ADT hash table
+//
+// Invariante:
+//    1. m_lElem < m_lSize
+//    2. die Elemente in m_Array wurden double-hashed erzeugt
+//
+class HashItem;
+
+class HashTable
+{
+    ULONG     m_lSize;
+    ULONG     m_lElem;
+    HashItem *m_pData;
+    double    m_dMaxLoadFactor;
+    double    m_dGrowFactor;
+    BOOL      m_bOwner;
+
+    ULONG Hash(String const& Key) const;
+    ULONG DHash(String const& Key, ULONG lHash) const;
+    ULONG Probe(ULONG lPos) const;
+
+    HashItem* FindPos(String const& Key) const;
+    void      SmartGrow();
+    double    CalcLoadFactor() const;
+
+// Statistik
+#ifdef DBG_UTIL
+private:
+    struct
+    {
+        ULONG m_lSingleHash;
+        ULONG m_lDoubleHash;
+        ULONG m_lProbe;
+    }
+        m_aStatistic;
+#endif
+
+protected:
+    friend class HashTableIterator;
+
+    virtual void OnDeleteObject(void* pObject);
+
+    void* GetObjectAt(ULONG lPos) const;
+
+// Default-Werte
+public:
+    static double m_defMaxLoadFactor;
+    static double m_defDefGrowFactor;
+
+public:
+    HashTable
+    (
+        ULONG   lSize,
+        BOOL    bOwner,
+        double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor /* 0.8 */,
+        double  dGrowFactor = HashTable::m_defDefGrowFactor /* 2.0 */
+    );
+
+    ~HashTable();
+
+    BOOL  IsFull() const;
+    ULONG GetSize() const { return m_lSize; }
+
+    void* Find   (String const& Key) const;
+    BOOL  Insert (String const& Key, void* pObject);
+    void* Delete (String const& Key);
+};
+
+// ADT hash table iterator
+//
+// Invariante: 0 <= m_lAt < m_aTable.GetCount()
+//
+class HashTableIterator
+{
+    ULONG            m_lAt;
+    HashTable const& m_aTable;
+
+    void* FindValidObject(BOOL bForward);
+
+protected:
+    void* GetFirst(); // Interation _ohne_ Sortierung
+    void* GetNext();
+    void* GetLast();
+    void* GetPrev();
+
+public:
+    HashTableIterator(HashTable const&);
+};
+
+// typsichere Makros ---------------------------------------------------
+
+#define DECLARE_HASHTABLE_INTERN(ClassName,Owner,KeyType,ObjType)       \
+    class ClassName : public HashTable                                  \
+    {                                                                   \
+    public:                                                             \
+        ClassName                                                       \
+        (                                                               \
+            ULONG   lSize,                                              \
+            double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor,     \
+            double  dGrowFactor = HashTable::m_defDefGrowFactor         \
+        )                                                               \
+        : HashTable(lSize,Owner,dMaxLoadFactor,dGrowFactor) {}          \
+                                                                        \
+        ObjType  Find (KeyType const& Key) const                        \
+        { return (ObjType) HashTable::Find(String(Key)); }              \
+                                                                        \
+        BOOL Insert (KeyType const& Key, ObjType Object)                \
+        { return HashTable::Insert(String(Key), (void*) Object); }      \
+                                                                        \
+        ObjType  Delete (KeyType const&Key)                             \
+        { return (ObjType) HashTable::Delete (String(Key)); }           \
+    };
+
+// HashTable OHNE Owner-Verhalten
+#define DECLARE_HASHTABLE(ClassName,KeyType,ObjType)                 \
+    DECLARE_HASHTABLE_INTERN(ClassName,FALSE,KeyType,ObjType)
+
+// HashTable MIT Owner-Verhalten
+#define DECLARE_HASHTABLE_OWNER(ClassName,KeyType,ObjType)           \
+    DECLARE_HASHTABLE_INTERN(ClassName##2,TRUE,KeyType,ObjType)      \
+    class ClassName : public ClassName##2                            \
+    {                                                                \
+    protected:                                                       \
+        virtual void OnDeleteObject(void* pObject);                  \
+    public:                                                          \
+        ClassName                                                    \
+        (                                                            \
+            ULONG   lSize,                                           \
+            double  dMaxLoadFactor = HashTable::m_defMaxLoadFactor,  \
+            double  dGrowFactor = HashTable::m_defDefGrowFactor      \
+        )                                                            \
+        : ClassName##2(lSize,dMaxLoadFactor,dGrowFactor) {}          \
+        ~ClassName();                                                \
+    };
+
+#define IMPLEMENT_HASHTABLE_OWNER(ClassName,KeyType,ObjType)         \
+    void ClassName::OnDeleteObject(void* pObject)                    \
+    { delete (ObjType) pObject; }                                    \
+                                                                     \
+    ClassName::~ClassName()                                          \
+    {                                                                \
+        for (ULONG i=0; i<GetSize(); i++)                            \
+        {                                                            \
+            void *pObject = GetObjectAt(i);                          \
+            if (pObject != NULL)                                     \
+                OnDeleteObject(pObject);                             \
+        }                                                            \
+    }
+
+// Iterator-Makros --------------------------------------------------
+
+#define DECLARE_HASHTABLE_ITERATOR(ClassName,ObjType)               \
+    class ClassName : public HashTableIterator                      \
+    {                                                               \
+    public:                                                         \
+        ClassName(HashTable const& aTable)                          \
+        : HashTableIterator(aTable) {}                              \
+                                                                    \
+        ObjType GetFirst()                                          \
+            { return (ObjType)HashTableIterator::GetFirst(); }      \
+        ObjType GetNext()                                           \
+            { return (ObjType)HashTableIterator::GetNext();  }      \
+        ObjType GetLast()                                           \
+            { return (ObjType)HashTableIterator::GetLast();  }      \
+        ObjType GetPrev()                                           \
+            { return (ObjType)HashTableIterator::GetPrev();  }      \
+    };
+
+
+#endif // _HASHTBL_HXX
+
diff --git a/tools/workben/makefile.mk b/tools/workben/makefile.mk
new file mode 100644
index 000000000000..8f76c20bbfd2
--- /dev/null
+++ b/tools/workben/makefile.mk
@@ -0,0 +1,119 @@
+#*************************************************************************
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1.1.1 $
+#
+#   last change: $Author: hr $ $Date: 2000-09-18 17:03:12 $
+#
+#   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=tl
+TARGET=tldem
+LIBTARGET=NO
+TARGETTYPE=CUI
+
+# --- Settings -----------------------------------------------------
+
+.INCLUDE :  svpre.mk
+.INCLUDE :  settings.mk
+.INCLUDE :  sv.mk
+
+# --- Files --------------------------------------------------------
+
+CXXFILES=   tldem.cxx solar.c demostor.cxx fstest.cxx
+
+OBJFILES=   $(OBJ)$/tldem.obj $(OBJ)$/solar.obj $(OBJ)$/demostor.obj $(OBJ)$/fstest.obj
+
+APP1TARGET= $(TARGET)
+APP1OBJS=   $(OBJ)$/tldem.obj
+.IF "$(GUI)" == "UNX"
+APP1LIBS=    $(TOOLSLIB)
+.ELSE
+APP1LIBS=   $(LB)$/itools.lib
+# APP1DEPN=   $(LB)$/$(TOOLSLIB)
+.ENDIF
+
+APP2TARGET= solar
+APP2OBJS=   $(OBJ)$/solar.obj
+.IF "$(GUI)" == "UNX"
+APP2STDLIBS=    $(TOOLSLIB)
+.ELSE
+APP2LIBS=   $(LB)$/itools.lib
+APP2DEPN=   $(LB)$/itools.lib
+.ENDIF
+
+APP3TARGET=     demostor
+APP3OBJS=       $(OBJ)$/demostor.obj
+.IF "$(GUI)" == "UNX"
+APP3STDLIBS=    $(TOOLSLIB) $(VOSLIB) $(SALLIB)
+.ELSE
+APP3STDLIBS=    $(LB)$/itools.lib ivos.lib isal.lib
+.ENDIF
+
+APP4TARGET=     fstest
+APP4OBJS=       $(OBJ)$/fstest.obj
+.IF "$(GUI)" == "UNX"
+APP4STDLIBS=    $(TOOLSLIB) $(VOSLIB) $(SALLIB)
+.ELSE
+APP4STDLIBS=    $(LB)$/itools.lib ivos.lib isal.lib
+.ENDIF
+
+# --- Targets ------------------------------------------------------
+
+.INCLUDE :  target.mk
+
diff --git a/tools/workben/solar.c b/tools/workben/solar.c
new file mode 100644
index 000000000000..f515824ff15b
--- /dev/null
+++ b/tools/workben/solar.c
@@ -0,0 +1,456 @@
+/*************************************************************************
+ *
+ *  $RCSfile: solar.c,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:03:12 $
+ *
+ *  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 <stdlib.h>
+
+typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
+typedef int (*TestFunc)( Type, void* );
+
+struct Description;
+
+int IsBigEndian(void);
+int IsStackGrowingDown_2( int * pI );
+int IsStackGrowingDown(void);
+int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... );
+int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c );
+int GetStackAlignment(void);
+void PrintArgs( int p, ... );
+int check( TestFunc func, Type eT, void* p );
+
+#if defined (UNX) || defined (WNT)
+
+#ifdef UNX
+#include <unistd.h>
+#endif
+#include <sys/types.h>
+
+#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) ? "unsigned" : "signed" ), Name )
+
+
+int IsBigEndian()
+{
+  long l = 1;
+  return ! *(char*)&l;
+}
+
+int IsStackGrowingDown_2( int * pI )
+{
+  int i = 1;
+  return ((unsigned long)&i) < (unsigned long)pI;
+}
+
+int IsStackGrowingDown()
+{
+  int i = 1;
+  return IsStackGrowingDown_2(&i);
+}
+
+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;
+}
+
+
+
+
+#if defined (UNX) || defined (WNT)
+
+#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
+static jmp_buf check_env;
+static int bSignal;
+#ifdef UNX
+void SignalHandler( int sig )
+#else
+void __cdecl SignalHandler( int sig )
+#endif
+{
+  bSignal = 1;
+  /*
+  fprintf( stderr, "Signal %d caught\n", sig );
+  signal( sig,  SignalHandler );
+  /**/
+  longjmp( check_env, sig );
+}
+#endif
+
+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,    SignalHandler );
+#ifdef UNX
+    signal( SIGBUS, SignalHandler );
+#else
+#endif
+    result = func( eT, p );
+    signal( SIGSEGV,    SIG_DFL );
+#ifdef UNX
+    signal( SIGBUS, SIG_DFL );
+#else
+#endif
+  }
+
+  if ( bSignal )
+    return -1;
+  else
+    return 0;
+#endif
+}
+
+#endif
+
+
+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();
+}
+
+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();
+}
+
+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;
+}
+
+int GetAlignment( Type eT )
+{
+  char  a[ 16*8 ];
+  int   p = (int)(void*)&a;
+  int   i;
+  p = ( p + 0xF ) & ~0xF;
+  for ( i = 1; i < 16; i++ )
+    if ( CheckGetAccess( eT, (void*)(p+i) ) )
+      return i;
+  return 0;
+}
+
+int CheckCharAccess( 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 );
+
+  return 0;
+}
+
+struct Description
+{
+  int   bBigEndian;
+  int   bStackGrowsDown;
+  int   nStackAlignment;
+  int   nAlignment[3];  /* 2,4,8 */
+}
+
+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(double) != 8 )
+    abort();
+  pThis->nAlignment[2] = GetAlignment( t_double );
+}
+
+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" );
+  fprintf( f, "#define _SOLAR_NODESCRIPTION\n" );
+}
+
+#ifdef WNT
+__cdecl
+#endif
+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)\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 );
+
+  {
+    char  a[64];
+    int   i = 56;
+    do
+    {
+      printf( "Zugriff long auf %i-Aligned Adresse : ", i / 7 );
+      printf( ( CheckGetAccess( t_long, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
+      i >>= 1;
+    } while( i >= 7 );
+  }
+
+  {
+    char  a[64];
+    int   i = 56;
+    do
+    {
+      printf( "Zugriff double auf %i-Aligned Adresse : ", i / 7 );
+      printf( ( CheckGetAccess( t_double, (double*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
+      i >>= 1;
+    } while( i >= 7 );
+  }
+
+  {
+    char* p = NULL;
+    CheckCharAccess( p );
+    p = (char*)&p;
+    CheckCharAccess( p );
+  }
+
+  if ( argc > 1 )
+  {
+    struct Description description;
+    Description_Ctor( &description );
+    Description_Print( &description, argv[1] );
+  }
+
+  exit( 0 );
+  return 0;
+}
diff --git a/tools/workben/tldem.cxx b/tools/workben/tldem.cxx
new file mode 100644
index 000000000000..842fe8fef20f
--- /dev/null
+++ b/tools/workben/tldem.cxx
@@ -0,0 +1,113 @@
+/*************************************************************************
+ *
+ *  $RCSfile: tldem.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:03:12 $
+ *
+ *  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 <fsys.hxx>
+#include <stream.hxx>
+#include <sstring.hxx>
+
+int
+#ifdef WNT
+__cdecl
+#endif
+main( int argc, char **argv )
+{
+    String aString;
+    aString = "*.*";
+    Dir aDir(aString);
+    SvFileStream aFile;
+    SvFileStream aSortedFile;
+
+    StringList *pList = new StringList;
+    SStringList *pSortedList = new SStringList;
+    ULONG nCount = aDir.Count();
+
+    for ( ULONG i=0; i<nCount; i++ )
+    {
+        aString = aDir[i].GetName();
+        pList->Insert( new String( aString ), LIST_APPEND );
+        pSortedList->PutString( new String( aString ));
+    }
+
+    aFile.Open( "test.dir", STREAM_WRITE );
+    for ( ULONG j=0; j<nCount; j++ )
+    {
+        aFile.WriteLine( *pList->GetObject(j) );
+    }
+    aFile.Close();
+
+
+    aSortedFile.Open( "stest.dir", STREAM_WRITE );
+    for ( ULONG k=0; k<nCount; k++ )
+    {
+        aSortedFile.WriteLine( *pSortedList->GetObject(k) );
+    }
+    if ( pSortedList->IsString( new String("bloedString")) != NOT_THERE )
+        aSortedFile.WriteLine( "Fehler !" );
+    if ( pSortedList->IsString( new String(".")) == NOT_THERE )
+        aSortedFile.WriteLine( "Fehler ?!?" );
+    aSortedFile.Close();
+
+    delete pList;
+    delete pSortedList;
+    return 0;
+}
+
+