lili/opennurbs
1
0
Fork 0
mirror of https://github.com/mcneel/opennurbs.git synced 2026-03-22 02:20:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

Sync changes from upstream repository

Browse Source 
Co-authored-by: Alain <alain@mcneel.com>
Co-authored-by: Andrew Le Bihan <andy@mcneel.com>
Co-authored-by: Bozo <bozo@mcneel.com>
Co-authored-by: chuck <chuck@mcneel.com>
Co-authored-by: Dale Fugier <dale@mcneel.com>
Co-authored-by: Giulio Piacentino <giulio@mcneel.com>
Co-authored-by: John Croudy <croudyj@gmail.com>
Co-authored-by: Mikko Oksanen <mikko@mcneel.com>
Co-authored-by: Pierre Cuvilliers <pierre@mcneel.com>
Co-authored-by: Steve Baer <steve@mcneel.com>
This commit is contained in:
Bozo The Builder
2022-08-08 05:51:20 -07:00
parent beeb16ad7e
commit 7eae26b304
930 changed files with 799452 additions and 799464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

582
opennurbs_workspace.cpp
View File

@@ -1,291 +1,291 @@
/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/
#include "opennurbs.h"
#if !defined(ON_COMPILING_OPENNURBS)
// This check is included in all opennurbs source .c and .cpp files to insure
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined
// and the opennurbs .h files alter what is declared and how it is declared.
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
#endif
ON_Workspace::ON_Workspace()
: m_pFileBlk(0)
, m_pMemBlk(0)
{}
ON_Workspace::~ON_Workspace()
{
Destroy();
}
struct ON_Workspace_FBLK
{
struct ON_Workspace_FBLK* pNext;
FILE* pFile;
} * m_pFileBlk;
struct ON_Workspace_MBLK
{
struct ON_Workspace_MBLK* pNext;
void* pMem;
} * m_pMemBlk;
void ON_Workspace::Destroy()
{
struct ON_Workspace_FBLK* pFileBlk = m_pFileBlk;
while ( pFileBlk ) {
if ( pFileBlk->pFile )
fclose( pFileBlk->pFile );
pFileBlk = pFileBlk->pNext;
}
m_pFileBlk = 0;
struct ON_Workspace_MBLK* pNext = m_pMemBlk;
struct ON_Workspace_MBLK* p = nullptr;
while ( pNext ) {
p = pNext;
pNext = pNext->pNext;
if ( p->pMem ) {
onfree(p->pMem);
p->pMem = nullptr;
}
onfree( p );
}
m_pMemBlk = 0;
}
void* ON_Workspace::GetMemory( size_t size )
{
void* p = nullptr;
if ( size > 0 )
{
struct ON_Workspace_MBLK* pBlk = (struct ON_Workspace_MBLK*)onmalloc(sizeof(*pBlk));
if ( pBlk )
{
pBlk->pMem = p = onmalloc(size);
pBlk->pNext = m_pMemBlk;
m_pMemBlk = pBlk;
}
}
return p;
}
void* ON_Workspace::GrowMemory( void* p, size_t size )
{
void* newp = nullptr;
if ( !p ) {
newp = GetMemory(size);
}
else {
struct ON_Workspace_MBLK* pBlk = m_pMemBlk;
while ( pBlk ) {
if ( pBlk->pMem == p ) {
if ( size > 0 ) {
newp = onrealloc(p,size);
}
else {
newp = p;
}
pBlk->pMem = newp;
break;
}
pBlk = pBlk->pNext;
}
}
return newp;
}
void ON_Workspace::KeepAllMemory()
{
struct ON_Workspace_MBLK* p;
struct ON_Workspace_MBLK* pNext = m_pMemBlk;
m_pMemBlk = 0;
while ( pNext )
{
p = pNext;
pNext = pNext->pNext;
p->pMem = 0; // caller want to manage this heap
onfree( p );
}
}
bool ON_Workspace::KeepMemory( void* p )
{
int rc = false;
if ( p ) {
struct ON_Workspace_MBLK* pPrevBlk = nullptr;
struct ON_Workspace_MBLK* pBlk = m_pMemBlk;
while ( pBlk ) {
if ( pBlk->pMem == p ) {
// Remove pBlk from list so ~ON_Workspace() won't onfree() its memory
// and any future GrowMemory...() or KeepMemory() calls won't have
// to search past it.
pBlk->pMem = nullptr;
if ( pPrevBlk ) {
pPrevBlk->pNext = pBlk->pNext;
}
else {
m_pMemBlk = pBlk->pNext;
}
onfree( pBlk );
rc = true;
break;
}
pPrevBlk = pBlk;
pBlk = pBlk->pNext;
}
}
return rc;
}
int* ON_Workspace::GetIntMemory( size_t size )
{
int* pi = (int*)(GetMemory(size*sizeof(*pi)));
return pi;
}
double* ON_Workspace::GetDoubleMemory( size_t size )
{
double* pd = (double*)(GetMemory(size*sizeof(*pd)));
return pd;
}
ON_3dPoint* ON_Workspace::GetPointMemory( size_t size )
{
ON_3dPoint* p3d = (ON_3dPoint*)(GetMemory(size*sizeof(*p3d)));
return p3d;
}
ON_3dVector* ON_Workspace::GetVectorMemory( size_t size )
{
ON_3dVector* v3d = (ON_3dVector*)(GetMemory(size*sizeof(*v3d)));
return v3d;
}
int** ON_Workspace::GetIntMemory( size_t row_count, size_t col_count )
{
int** p = 0;
size_t i;
if ( row_count > 0 && col_count > 0 )
{
p = (int**)GetMemory(row_count*(sizeof(*p) + col_count*sizeof(**p)));
if ( p )
{
p[0] = (int*)(p+row_count);
for( i = 1; i < row_count; i++ )
{
p[i] = p[i-1] + col_count;
}
}
}
return p;
}
double** ON_Workspace::GetDoubleMemory( size_t row_count, size_t col_count )
{
double** p = 0;
size_t i;
if ( row_count > 0 && col_count > 0 )
{
// i keeps doubles aligned
i = (sizeof(*p) < sizeof(**p))
? (row_count + (row_count%2))
: row_count;
p = (double**)GetMemory(i*sizeof(*p) + row_count*col_count*sizeof(**p));
if ( p )
{
p[0] = (double*)(p+i);
for( i = 1; i < row_count; i++ )
{
p[i] = p[i-1] + col_count;
}
}
}
return p;
}
int* ON_Workspace::GrowIntMemory( int* p, size_t size )
{
int* pi = (int*)(GrowMemory(p,size*sizeof(*pi)));
return pi;
}
double* ON_Workspace::GrowDoubleMemory( double* p, size_t size )
{
double* pd = (double*)(GrowMemory(p,size*sizeof(*pd)));
return pd;
}
ON_3dPoint* ON_Workspace::GrowPointMemory( ON_3dPoint* p, size_t size )
{
ON_3dPoint* p3d = (ON_3dPoint*)(GrowMemory(p,size*sizeof(*p3d)));
return p3d;
}
ON_3dVector* ON_Workspace::GrowVectorMemory( ON_3dVector* p, size_t size )
{
ON_3dVector* v3d = (ON_3dVector*)(GrowMemory(p,size*sizeof(*v3d)));
return v3d;
}
FILE* ON_Workspace::OpenFile( const char* sFileName, const char* sMode )
{
FILE* pFile = ON::OpenFile( sFileName, sMode );
if ( pFile )
{
struct ON_Workspace_FBLK* pFileBlk = (struct ON_Workspace_FBLK*)GetMemory( sizeof(*pFileBlk) );
pFileBlk->pNext = m_pFileBlk;
pFileBlk->pFile = pFile;
m_pFileBlk = pFileBlk;
}
return pFile;
}
FILE* ON_Workspace::OpenFile( const wchar_t* sFileName, const wchar_t* sMode )
{
FILE* pFile = ON::OpenFile( sFileName, sMode );
if ( pFile )
{
struct ON_Workspace_FBLK* pFileBlk = (struct ON_Workspace_FBLK*)GetMemory( sizeof(*pFileBlk) );
pFileBlk->pNext = m_pFileBlk;
pFileBlk->pFile = pFile;
m_pFileBlk = pFileBlk;
}
return pFile;
}
bool ON_Workspace::KeepFile( FILE* pFile )
{
bool rc = false;
if ( pFile ) {
struct ON_Workspace_FBLK* pFileBlk = m_pFileBlk;
while ( pFileBlk ) {
if ( pFileBlk->pFile == pFile ) {
pFileBlk->pFile = nullptr;
rc = true;
break;
}
pFileBlk = pFileBlk->pNext;
}
}
return rc;
}
/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/
#include "opennurbs.h"
#if !defined(ON_COMPILING_OPENNURBS)
// This check is included in all opennurbs source .c and .cpp files to insure
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined
// and the opennurbs .h files alter what is declared and how it is declared.
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
#endif
ON_Workspace::ON_Workspace()
: m_pFileBlk(0)
, m_pMemBlk(0)
{}
ON_Workspace::~ON_Workspace()
{
Destroy();
}
struct ON_Workspace_FBLK
{
struct ON_Workspace_FBLK* pNext;
FILE* pFile;
} * m_pFileBlk;
struct ON_Workspace_MBLK
{
struct ON_Workspace_MBLK* pNext;
void* pMem;
} * m_pMemBlk;
void ON_Workspace::Destroy()
{
struct ON_Workspace_FBLK* pFileBlk = m_pFileBlk;
while ( pFileBlk ) {
if ( pFileBlk->pFile )
fclose( pFileBlk->pFile );
pFileBlk = pFileBlk->pNext;
}
m_pFileBlk = 0;
struct ON_Workspace_MBLK* pNext = m_pMemBlk;
struct ON_Workspace_MBLK* p = nullptr;
while ( pNext ) {
p = pNext;
pNext = pNext->pNext;
if ( p->pMem ) {
onfree(p->pMem);
p->pMem = nullptr;
}
onfree( p );
}
m_pMemBlk = 0;
}
void* ON_Workspace::GetMemory( size_t size )
{
void* p = nullptr;
if ( size > 0 )
{
struct ON_Workspace_MBLK* pBlk = (struct ON_Workspace_MBLK*)onmalloc(sizeof(*pBlk));
if ( pBlk )
{
pBlk->pMem = p = onmalloc(size);
pBlk->pNext = m_pMemBlk;
m_pMemBlk = pBlk;
}
}
return p;
}
void* ON_Workspace::GrowMemory( void* p, size_t size )
{
void* newp = nullptr;
if ( !p ) {
newp = GetMemory(size);
}
else {
struct ON_Workspace_MBLK* pBlk = m_pMemBlk;
while ( pBlk ) {
if ( pBlk->pMem == p ) {
if ( size > 0 ) {
newp = onrealloc(p,size);
}
else {
newp = p;
}
pBlk->pMem = newp;
break;
}
pBlk = pBlk->pNext;
}
}
return newp;
}
void ON_Workspace::KeepAllMemory()
{
struct ON_Workspace_MBLK* p;
struct ON_Workspace_MBLK* pNext = m_pMemBlk;
m_pMemBlk = 0;
while ( pNext )
{
p = pNext;
pNext = pNext->pNext;
p->pMem = 0; // caller want to manage this heap
onfree( p );
}
}
bool ON_Workspace::KeepMemory( void* p )
{
int rc = false;
if ( p ) {
struct ON_Workspace_MBLK* pPrevBlk = nullptr;
struct ON_Workspace_MBLK* pBlk = m_pMemBlk;
while ( pBlk ) {
if ( pBlk->pMem == p ) {
// Remove pBlk from list so ~ON_Workspace() won't onfree() its memory
// and any future GrowMemory...() or KeepMemory() calls won't have
// to search past it.
pBlk->pMem = nullptr;
if ( pPrevBlk ) {
pPrevBlk->pNext = pBlk->pNext;
}
else {
m_pMemBlk = pBlk->pNext;
}
onfree( pBlk );
rc = true;
break;
}
pPrevBlk = pBlk;
pBlk = pBlk->pNext;
}
}
return rc;
}
int* ON_Workspace::GetIntMemory( size_t size )
{
int* pi = (int*)(GetMemory(size*sizeof(*pi)));
return pi;
}
double* ON_Workspace::GetDoubleMemory( size_t size )
{
double* pd = (double*)(GetMemory(size*sizeof(*pd)));
return pd;
}
ON_3dPoint* ON_Workspace::GetPointMemory( size_t size )
{
ON_3dPoint* p3d = (ON_3dPoint*)(GetMemory(size*sizeof(*p3d)));
return p3d;
}
ON_3dVector* ON_Workspace::GetVectorMemory( size_t size )
{
ON_3dVector* v3d = (ON_3dVector*)(GetMemory(size*sizeof(*v3d)));
return v3d;
}
int** ON_Workspace::GetIntMemory( size_t row_count, size_t col_count )
{
int** p = 0;
size_t i;
if ( row_count > 0 && col_count > 0 )
{
p = (int**)GetMemory(row_count*(sizeof(*p) + col_count*sizeof(**p)));
if ( p )
{
p[0] = (int*)(p+row_count);
for( i = 1; i < row_count; i++ )
{
p[i] = p[i-1] + col_count;
}
}
}
return p;
}
double** ON_Workspace::GetDoubleMemory( size_t row_count, size_t col_count )
{
double** p = 0;
size_t i;
if ( row_count > 0 && col_count > 0 )
{
// i keeps doubles aligned
i = (sizeof(*p) < sizeof(**p))
? (row_count + (row_count%2))
: row_count;
p = (double**)GetMemory(i*sizeof(*p) + row_count*col_count*sizeof(**p));
if ( p )
{
p[0] = (double*)(p+i);
for( i = 1; i < row_count; i++ )
{
p[i] = p[i-1] + col_count;
}
}
}
return p;
}
int* ON_Workspace::GrowIntMemory( int* p, size_t size )
{
int* pi = (int*)(GrowMemory(p,size*sizeof(*pi)));
return pi;
}
double* ON_Workspace::GrowDoubleMemory( double* p, size_t size )
{
double* pd = (double*)(GrowMemory(p,size*sizeof(*pd)));
return pd;
}
ON_3dPoint* ON_Workspace::GrowPointMemory( ON_3dPoint* p, size_t size )
{
ON_3dPoint* p3d = (ON_3dPoint*)(GrowMemory(p,size*sizeof(*p3d)));
return p3d;
}
ON_3dVector* ON_Workspace::GrowVectorMemory( ON_3dVector* p, size_t size )
{
ON_3dVector* v3d = (ON_3dVector*)(GrowMemory(p,size*sizeof(*v3d)));
return v3d;
}
FILE* ON_Workspace::OpenFile( const char* sFileName, const char* sMode )
{
FILE* pFile = ON::OpenFile( sFileName, sMode );
if ( pFile )
{
struct ON_Workspace_FBLK* pFileBlk = (struct ON_Workspace_FBLK*)GetMemory( sizeof(*pFileBlk) );
pFileBlk->pNext = m_pFileBlk;
pFileBlk->pFile = pFile;
m_pFileBlk = pFileBlk;
}
return pFile;
}
FILE* ON_Workspace::OpenFile( const wchar_t* sFileName, const wchar_t* sMode )
{
FILE* pFile = ON::OpenFile( sFileName, sMode );
if ( pFile )
{
struct ON_Workspace_FBLK* pFileBlk = (struct ON_Workspace_FBLK*)GetMemory( sizeof(*pFileBlk) );
pFileBlk->pNext = m_pFileBlk;
pFileBlk->pFile = pFile;
m_pFileBlk = pFileBlk;
}
return pFile;
}
bool ON_Workspace::KeepFile( FILE* pFile )
{
bool rc = false;
if ( pFile ) {
struct ON_Workspace_FBLK* pFileBlk = m_pFileBlk;
while ( pFileBlk ) {
if ( pFileBlk->pFile == pFile ) {
pFileBlk->pFile = nullptr;
rc = true;
break;
}
pFileBlk = pFileBlk->pNext;
}
}
return rc;
}