Skip to content

C
core
Kaydet (Commit) 416010c7 authored tarafından Caolán McNamara's avatar Caolán McNamara
Dosyalara gözat
Seçenekler

ditch useless, duplicated or non-recoverable workben files

üst 331b377c
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 1363 deletions
tools/workben/fstest.cxx deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#define _FSTEST_CXX
#include <tools/solar.h>
#include <stdio.h>
#include <tools/stream.hxx>
#include <tools/fsys.hxx>
#include <tools/date.hxx>
#include <tools/time.hxx>
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;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools/workben/hashtbl.cxx deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <tlgen.hxx>
#include "hashtbl.hxx"
#include <algorithm>
// -------------------------------------------------------------
// 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 = std::max(0.5,std::min(1.0,dMaxLoadFactor)); // 0.5 ... 1.0
m_dGrowFactor = std::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,
// mssen 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 fr HashItems freigeben
delete [] m_pData;
}
void* HashTable::GetObjectAt(ULONG lPos) const
// Gibt Objekt zurck, 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*)
{
OSL_FAIL("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 zurck
{
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 erhht
{
SmartGrow();
if (IsFull())
{
OSL_FAIL("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) zurck
//
// 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 zurck, 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)
// Lscht Objekt, das unter Key abgespeichert ist und gibt Verweis
// darauf zurck.
// Gibt NULL zurck, wenn Key nicht vorhanden ist.
//
// pre: -
// post: Objekt ist nicht mehr enthalten; m_lElem dekrementiert
// Wenn die HashTable der Owner ist, wurde das Object gelscht
{
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 Gre
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;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools/workben/hashtbl.hxx deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#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
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools/workben/helloworld.c deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <stdlib.h>
#include <io.h>
main( )
{
printf( "%s\n", "hello world");
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools/workben/makefile.mk deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
#*************************************************************************
#
# 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.
#
#*************************************************************************
PRJ = ..
PRJNAME = tools
TARGET = workben
LIBTARGET = NO
TARGETTYPE = CUI
ENABLE_EXCEPTIONS=TRUE
.INCLUDE: settings.mk
OBJFILES = \
$(OBJ)$/solar.obj \
$(OBJ)$/urltest.obj \
$(OBJ)$/inetmimetest.obj \
$(OBJ)$/mempooltest.obj
APP1TARGET = solar
APP1OBJS = $(OBJ)$/solar.obj
.IF "$(GUI)" == "UNX"
APP1STDLIBS = $(TOOLSLIB)
.ELSE
APP1LIBS = $(LB)$/itools.lib
.ENDIF
APP2TARGET = urltest
APP2OBJS = $(OBJ)$/urltest.obj
.IF "$(GUI)" == "UNX"
APP2STDLIBS = $(TOOLSLIB) $(VOSLIB) $(SALLIB) $(CPPULIB) $(CPPUHELPERLIB)
.ELSE
APP2STDLIBS = $(LB)$/itools.lib $(VOSLIB) $(SALLIB) $(CPPULIB) $(CPPUHELPERLIB)
.ENDIF
APP3TARGET = inetmimetest
APP3OBJS = $(OBJ)$/inetmimetest.obj
APP3STDLIBS = $(SALLIB) $(TOOLSLIB)
APP4TARGET = mempooltest
APP4OBJS = $(OBJ)$/mempooltest.obj
APP4STDLIBS = $(TOOLSLIB)
APP4RPATH = UREBIN
.INCLUDE: target.mk
tools/workben/mempooltest.cxx deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#include "tools/mempool.hxx"
struct MempoolTest
{
int m_int;
DECL_FIXEDMEMPOOL_NEWDEL(MempoolTest);
};
IMPL_FIXEDMEMPOOL_NEWDEL(MempoolTest);
int main()
{
MempoolTest * p = new MempoolTest();
if (p != 0)
delete p;
return 1;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools/workben/solar.c deleted 100644 → 0
Dosyayı görüntüle @ 331b377c
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#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, ... )
{
(void) p; (void) l; (void) i; (void) s; /* unused */
if ( IsStackGrowingDown() )
return &c - &b;
else
return &b - &c;
}
int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c )
{
(void) p; (void) l; (void) i; (void) s; /* unused */
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;
void SAL_CALL SignalHandler( int sig )
{
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 );
#if OSL_DEBUG_LEVEL > 1
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 );
#if OSL_DEBUG_LEVEL > 1
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 */
};
void 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 );
}
void 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" );
fclose(f);
}
int SAL_CALL 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;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment