[wxWidgets.git] / utils / HelpGen / src / scriptbinder.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        No names yet.
// Purpose:     Contrib. demo
// Author:      Aleksandras Gluchovas
// Modified by:
// Created:     22/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Aleskandars Gluchovas
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include <malloc.h>
#include <string.h>
#include <memory.h>

#include <stdio.h>   // import sprintf() (for doubles)
#include <stdlib.h>  // import atoi()    (for integers)

#include "scriptbinder.h"

// helper functions

static size_t log2(size_t nr)
{
	size_t tmp = 0;
	while (nr >= 2 ) 
	{
		nr /= 2;
		++tmp;
	}

	return tmp;
}

/***** Implementation for class ScriptStream *****/

ScriptStream::ScriptStream()
	: mpBuf(0),
	  mSize(0),
	  mCapacity(0)
{}

ScriptStream::~ScriptStream()
{
	if ( mpBuf ) delete mpBuf;
}

void ScriptStream::WriteBytes( const void* srcBuf, size_t count )
{
	if ( !count ) return;

	// increase the capacity if necessary
	if ( mSize + count > mCapacity )
	{
			mCapacity = 
				(  0x2 << (log2( mSize + count ) + 1 ) );

			if ( mCapacity < 128 ) mCapacity = 128;

			char* oldBuf = mpBuf;

			mpBuf = new char[mCapacity];

			if ( oldBuf )
			{
				memcpy( mpBuf, oldBuf, mSize );
				delete oldBuf;
			}
	}

	// append new data
	memcpy( &mpBuf[mSize], srcBuf, count );

	mSize += count;
}

ScriptStream& ScriptStream::operator<<( const char* str )
{
	WriteBytes( str, strlen( str ) );

	return *this;
}

ScriptStream& ScriptStream::operator<<( const string& str )
{
	if ( str.length() < 512 )
	{
		char buf[512];
		size_t len = str.length();

		for( size_t i = 0; i != len; ++i )
			buf[i] = str[i];

		WriteBytes( buf, len );
	}
	else
		WriteBytes( str.c_str(), str.length() );

	return *this;
}

ScriptStream& ScriptStream::operator<<( char ch )
{
	WriteBytes( &ch, 1 );

	return *this;
}

void ScriptStream::endl()
{
	char ch = '\n';
	WriteBytes( &ch, 1 );
}

/***** Implementation for class ScriptTemplate *****/

ScriptTemplate::ScriptTemplate( const string& templateText )
{
	string tmp = templateText;

	mTText = (char*)malloc( tmp.length() + 1 );

	strcpy( mTText, tmp.c_str() );
}

ScriptTemplate::~ScriptTemplate()
{
	for( size_t i = 0; i != mVars.size(); ++i )

		delete mVars[i];

	free( mTText );
}

bool ScriptTemplate::HasVar( const char* name )
{
	for( size_t i = 0; i != mVars.size(); ++i ) 

		if ( strcmp( mVars[i]->mName, name ) == 0 )

			return 1;

	return 0;
}

void ScriptTemplate::AddStringVar ( const char* name, int ofs )
{
	mVars.push_back( new TVarInfo( name, ofs, TVAR_STRING ) );
}

void ScriptTemplate::AddIntegerVar( const char* name, int ofs )
{
	mVars.push_back( new TVarInfo( name, ofs, TVAR_INTEGER ) );
}

void ScriptTemplate::AddDoubleVar ( const char* name, int ofs )
{
	mVars.push_back( new TVarInfo( name, ofs, TVAR_DOUBLE ) );
}

void ScriptTemplate::AddObjectRefArray( const char*     name,
										int			    ofsRefToFirstObj,
										int			    ofsObjSizeInt,
										int			    ofsObjRefTempl
									  )
{
	TArrayInfo* pInfo = new TArrayInfo( name );

	mVars.push_back( pInfo );

	pInfo->mRefOfs         = ofsRefToFirstObj;
	pInfo->mSizeIntOfs     = ofsObjSizeInt;
	pInfo->mObjRefTemplOfs = ofsObjRefTempl;
}

inline void ScriptTemplate::PrintVar( TVarInfo*   pInfo, 
								    void*       dataObj, 
									ScriptStream& stm )
{
	char buf[128];

	switch ( pInfo->mType )
	{
		case TVAR_INTEGER :
			{
				sprintf(buf, "%d",*( (int*) ((char*)dataObj + pInfo->mOfs) ) );
				
				stm.WriteBytes( buf, strlen(buf ) );
				break;
			}

		case TVAR_STRING :
			{
				string& str = *( (string*) ((char*)dataObj+pInfo->mOfs) );

				const char* cs = str.c_str();
#ifdef DEBUG_WEIRED_OFFSETS
				cout << "DBG:: cs address is " << (int)cs << endl;
				cout << "DBG:: str address is " << (int)(&str) << endl;
				cout << "DBG:: dataObj points to " << (int)dataObj << endl;
				cout << "DBG:: pInfo->mOfs value is " << (int)pInfo->mOfs << endl;
				cout << "DBG:: d+pInfo->mOfs is " << (int)((char*)dataObj + pInfo->mOfs) << endl;
				cout << "DBG:: pInfo->mName is " << pInfo->mName << endl;
				cout << "DBG:: pInfo->mType is " << pInfo->mType << endl;
				cout << "DBG:: end of dump. " << endl;

				cout << "DBG:: cs value is " << endl << cs << endl;
#endif
				stm.WriteBytes( cs, strlen(cs) );
				break;
			}

		case TVAR_DOUBLE :
			{
				sprintf( buf, "%f", 
					     *( (double*)( (char*)dataObj+pInfo->mOfs)  ) );

				stm.WriteBytes( buf, strlen(buf ) );
				break;
			}

		case TVAR_REF_ARRAY :
			{
				TArrayInfo& info = *((TArrayInfo*)pInfo);

				int sz = *((int*) ( (char*)dataObj+info.mSizeIntOfs ));
				if ( !sz ) 
				{
					// DBG::
					int u;
					++u;
					break;
				}

				int*   array = *((int**)( (char*)dataObj+info.mRefOfs ));
	
				ScriptTemplate* pRefTempl;

				for( int i = 0; i != sz; ++i )
				{
					pRefTempl = 
						*((ScriptTemplate**)((char*)(array[i])+info.mObjRefTemplOfs));

					pRefTempl->PrintScript( (void*)array[i], stm );
				}

				break;
			}

		default : break;
	}
}

void ScriptTemplate::PrintScript( void* dataObj, ScriptStream& stm )
{
	char* cur   = mTText;

	// template parsing loop
	do
	{
		char* start = cur;

		while( *cur != '\0' && *cur != '$' ) ++cur;

		// flush text collected between variables
		stm.WriteBytes( start, cur - start );

		if ( *cur == '\0' ) break;

		cur += 2; // skip to the name of the var

		start = cur;

		while( *cur != ')' ) ++cur;

		// put terminating zero temorarely

		*cur = '\0';

		// look up variable

		size_t sz = mVars.size();
		bool found = 0;

		for( size_t i = 0; i != sz; ++i ) 
		{
			if ( strcmp( mVars[i]->mName, start ) == 0 )
			{
				PrintVar( mVars[i], dataObj, stm );

				*cur = ')';	// remove terminating zero
				++cur;
				found = 1;
				break;
			}
		}

		// variable referred by template script is not
		// registered to this tempalte object
		ASSERT( found ); 

	} while(1);
}

/***** implementation for class ScriptSection *****/

int ScriptSection::mIdCounter = 0;

ScriptSection::ScriptSection( const string&   name,
						      const string&   body,
							  ScriptTemplate* pSectionTemplate,
							  ScriptTemplate* pReferenceTemplate,
							  bool            autoHide,
							  bool            sorted
							)
	: mpParent ( NULL ),

	  mName    ( name ),
	  mBody    ( body ),

	  mAutoHide( autoHide ),
	  mSortOn  ( sorted ),

	  mpSectTempl( pSectionTemplate ),
	  mpRefTempl ( pReferenceTemplate ),

	  mRefCount( 0 ),
	  mArrSize( 0 )
{
	// generate GUID

	char buf[32];
	sprintf( buf, "%d", ++mIdCounter );
	mId = buf;
}

ScriptSection::~ScriptSection()
{
	SectListT lst = mSubsections;

	while( mSubsections.size() )

		mSubsections[0]->RemoveRef();

	for( size_t i = 0; i != mReferences.size(); ++i )

		mReferences[i]->RemoveRef();
}

void ScriptSection::AddRef()
{
	++mRefCount;
}

void ScriptSection::RemoveRef()
{
	if ( !mRefCount || !(--mRefCount) )
	{
		if (mpParent)
		{
			// remove ourselves from parent's list

			SectListT& lst = mpParent->mSubsections;
			for( size_t i = 0; i != lst.size(); ++i )

				if ( lst[i] == this )
				{
					lst.erase( &lst[i] );
					break;
				}
		}

		delete this;
	}
}

ScriptSection* ScriptSection::GetSubsection( const char* name )
{
	// FOR NOW:: fixed section name length
	char buf[128];

	size_t cur = 0;

	while( name[cur] && name[cur] != '/' )
	{
		buf[cur] = name[cur];
		++cur;
	}

	ASSERT( cur < sizeof(buf) );

	buf[cur] = '\0';

	size_t sz = mSubsections.size();

	for( size_t i = 0; i != sz; ++i )
	{
		// DBG::
		//ScriptSection& sect = *mSubsections[i];

		if ( mSubsections[i]->mName == buf )
		{
			if ( name[cur] == '/' )

				// search recursivelly
				return mSubsections[i]->GetSubsection( &name[cur+1] );
			else
				return mSubsections[i];
		}
	}

	return 0;
}

void ScriptSection::AddSection( ScriptSection* pSection,
							    bool addToReferencesToo
							  )
{
	mSubsections.push_back( pSection );

	pSection->AddRef();

	// can add section to multiple containers
	ASSERT( pSection->mpParent == 0 );

	pSection->mpParent = this;

	if ( addToReferencesToo )

		AddReference( pSection );
}

void ScriptSection::AddReference( ScriptSection* pReferredSection )
{
	mReferences.push_back( pReferredSection );

	pReferredSection->AddRef();

	// set up mandatory fields used by ScriptTemplate
	mArrSize  = mReferences.size();
	if ( mArrSize )
		mRefFirst = (void*)&mReferences[0];
}

SectListT& ScriptSection::GetSubsections()
{
	return mSubsections;
}

// static method:
void ScriptSection::RegisterTemplate( ScriptTemplate& sectionTempalte )
{
	int nameOfs, bodyOfs, idOfs,
		arrRefOfs, arrSizeOfs, refTemplOfs;

	// obtaining offsets of member vars
	
	GET_VAR_OFS( ScriptSection, mName,     &nameOfs    )
	GET_VAR_OFS( ScriptSection, mBody,     &bodyOfs    )
	GET_VAR_OFS( ScriptSection, mId,       &idOfs      )
	GET_VAR_OFS( ScriptSection, mRefFirst, &arrRefOfs  )
	GET_VAR_OFS( ScriptSection, mArrSize,  &arrSizeOfs )

	GET_VAR_OFS( ScriptSection, mpRefTempl, &refTemplOfs )

	// registering member variables with given script template

	sectionTempalte.AddStringVar( "NAME", nameOfs );
	sectionTempalte.AddStringVar( "BODY", bodyOfs );
	sectionTempalte.AddStringVar( "ID",   idOfs   );

	sectionTempalte.AddObjectRefArray( "REFLIST",
									   arrRefOfs, arrSizeOfs, refTemplOfs );
}

void ScriptSection::Print( ScriptStream& stm )
{
	// TBD:: sorting

	// print out this content first
	if ( mpSectTempl )

		mpSectTempl->PrintScript( this, stm );

	// attach contents subsections at the end of this content

	for( size_t i = 0; i != mSubsections.size(); ++i )

		mSubsections[i]->Print( stm );
}

void ScriptSection::DoRemoveEmptySections(int& nRemoved, SectListT& removedLst)
{
	for( size_t i = 0; i != mSubsections.size(); ++i )
	{
		ScriptSection& sect = *mSubsections[i];

		sect.DoRemoveEmptySections( nRemoved, removedLst );

		if (sect.mAutoHide )
			
			if ( sect.mReferences.size() == 0 )
			{
				bool found = 0;
				for( size_t k = 0; k != removedLst.size(); ++k )

					if ( removedLst[k] == &sect )
					{
						found = 1;
						break;
					}
				
				if ( !found )
				{
					removedLst.push_back( &sect );
					++nRemoved;

					delete &sect;
					--i;
				}
			}
	}
}

void ScriptSection::DoRemoveDeadLinks( SectListT& removedLst)
{
	size_t dsz = removedLst.size();

	for( size_t i = 0; i != mSubsections.size(); ++i )
	{
		mSubsections[i]->DoRemoveDeadLinks( removedLst );
	}

	for( size_t n = 0; n != mReferences.size(); ++n )
	{
		for( size_t k = 0; k != dsz; ++k )

			if ( removedLst[k] == mReferences[n] )
			{
				mReferences.erase( &mReferences[n] );
				--n;

				// set up mandatory fields used by ScriptTemplate
				mArrSize  = mReferences.size();
				if ( mArrSize )
					mRefFirst = (void*)&mReferences[0];

				break;
			}
	}
}


void ScriptSection::RemoveEmptySections()
{
	// FIXME:: this is very_very_very slow alg.! +"doesn't work"

	int nRemoved = 0;

	do
	{
		SectListT removedLst;
		nRemoved = 0;

		DoRemoveEmptySections( nRemoved, removedLst );

		DoRemoveDeadLinks( removedLst );
	}
	while( nRemoved );
}

/***** Iimplementation for class DocGeneratorBase *****/

bool DocGeneratorBase::SaveDocument( const char*    fname, 
								     const char*    fopenOptions,
								     ScriptSection* pFromSection
								   )
{
	FILE* fp = fopen( fname, fopenOptions );

	if ( (int)fp == -1 ) return 0;

	ScriptStream stm;

	// check if derived class agrees about saving it
	if ( !OnSaveDocument( stm ) ) return 0;

	if ( pFromSection )

		pFromSection->Print( stm );
	else
	{
		ScriptSection* pTopSect = GetTopSection();
		ASSERT( pTopSect );
		pTopSect->Print( stm );
	}

	size_t nWrite = fwrite( stm.GetBuf(), 1, stm.GetBufSize(), fp );

	if ( nWrite != stm.GetBufSize() ) return 0;

	fclose( fp );

	return 1;

	// that^s it
}
Commit	Line	Data
cecfc5e7 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: No names yet.
	3	// Purpose: Contrib. demo
	4	// Author: Aleksandras Gluchovas
	5	// Modified by:
	6	// Created: 22/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Aleskandars Gluchovas
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx/wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif
	22
	23	#include <malloc.h>
	24	#include <string.h>
	25	#include <memory.h>
	26
	27	#include <stdio.h> // import sprintf() (for doubles)
	28	#include <stdlib.h> // import atoi() (for integers)
	29
	30	#include "scriptbinder.h"
	31
	32	// helper functions
	33
	34	static size_t log2(size_t nr)
	35	{
	36	size_t tmp = 0;
	37	while (nr >= 2 )
	38	{
	39	nr /= 2;
	40	++tmp;
	41	}
	42
	43	return tmp;
	44	}
	45
	46	/*** Implementation for class ScriptStream ***/
	47
	48	ScriptStream::ScriptStream()
	49	: mpBuf(0),
	50	mSize(0),
	51	mCapacity(0)
	52	{}
	53
	54	ScriptStream::~ScriptStream()
	55	{
	56	if ( mpBuf ) delete mpBuf;
	57	}
	58
	59	void ScriptStream::WriteBytes( const void* srcBuf, size_t count )
	60	{
	61	if ( !count ) return;
	62
	63	// increase the capacity if necessary
	64	if ( mSize + count > mCapacity )
65	{
66	mCapacity =
67	( 0x2 << (log2( mSize + count ) + 1 ) );
68
69	if ( mCapacity < 128 ) mCapacity = 128;
70
71	char* oldBuf = mpBuf;
72
73	mpBuf = new char[mCapacity];
74
75	if ( oldBuf )
76	{
77	memcpy( mpBuf, oldBuf, mSize );
78	delete oldBuf;
79	}
80	}
81
82	// append new data
83	memcpy( &mpBuf[mSize], srcBuf, count );
84
85	mSize += count;
86	}
87
88	ScriptStream& ScriptStream::operator<<( const char* str )
89	{
90	WriteBytes( str, strlen( str ) );
91
92	return *this;
93	}
94
95	ScriptStream& ScriptStream::operator<<( const string& str )
96	{
97	if ( str.length() < 512 )
98	{
99	char buf[512];
100	size_t len = str.length();
101
102	for( size_t i = 0; i != len; ++i )
103	buf[i] = str[i];
104
105	WriteBytes( buf, len );
106	}
107	else
108	WriteBytes( str.c_str(), str.length() );
109
110	return *this;
111	}
112
113	ScriptStream& ScriptStream::operator<<( char ch )
114	{
115	WriteBytes( &ch, 1 );
116
117	return *this;
118	}
119
120	void ScriptStream::endl()
121	{
122	char ch = '\n';
123	WriteBytes( &ch, 1 );
124	}
125
126	/*** Implementation for class ScriptTemplate ***/
127
128	ScriptTemplate::ScriptTemplate( const string& templateText )
129	{
130	string tmp = templateText;
131
132	mTText = (char*)malloc( tmp.length() + 1 );
133
134	strcpy( mTText, tmp.c_str() );
135	}
136
137	ScriptTemplate::~ScriptTemplate()
138	{
139	for( size_t i = 0; i != mVars.size(); ++i )
140
141	delete mVars[i];
142
143	free( mTText );
144	}
145
146	bool ScriptTemplate::HasVar( const char* name )
147	{
148	for( size_t i = 0; i != mVars.size(); ++i )
149
150	if ( strcmp( mVars[i]->mName, name ) == 0 )
151
152	return 1;
153
154	return 0;
155	}
156
157	void ScriptTemplate::AddStringVar ( const char* name, int ofs )
158	{
159	mVars.push_back( new TVarInfo( name, ofs, TVAR_STRING ) );
160	}
161
162	void ScriptTemplate::AddIntegerVar( const char* name, int ofs )
163	{
164	mVars.push_back( new TVarInfo( name, ofs, TVAR_INTEGER ) );
165	}
166
167	void ScriptTemplate::AddDoubleVar ( const char* name, int ofs )
168	{
169	mVars.push_back( new TVarInfo( name, ofs, TVAR_DOUBLE ) );
170	}
171
172	void ScriptTemplate::AddObjectRefArray( const char* name,
173	int ofsRefToFirstObj,
174	int ofsObjSizeInt,
175	int ofsObjRefTempl
176	)
177	{
178	TArrayInfo* pInfo = new TArrayInfo( name );
179
180	mVars.push_back( pInfo );
181
182	pInfo->mRefOfs = ofsRefToFirstObj;
183	pInfo->mSizeIntOfs = ofsObjSizeInt;
184	pInfo->mObjRefTemplOfs = ofsObjRefTempl;
185	}
186
187	inline void ScriptTemplate::PrintVar( TVarInfo* pInfo,
188	void* dataObj,
189	ScriptStream& stm )
190	{
191	char buf[128];
192
193	switch ( pInfo->mType )
194	{
195	case TVAR_INTEGER :
196	{
197	sprintf(buf, "%d",( (int) ((char*)dataObj + pInfo->mOfs) ) );
198
199	stm.WriteBytes( buf, strlen(buf ) );
200	break;
201	}
202
203	case TVAR_STRING :
204	{
205	string& str = ( (string) ((char*)dataObj+pInfo->mOfs) );
206
207	const char* cs = str.c_str();
208	#ifdef DEBUG_WEIRED_OFFSETS
209	cout << "DBG:: cs address is " << (int)cs << endl;
210	cout << "DBG:: str address is " << (int)(&str) << endl;
211	cout << "DBG:: dataObj points to " << (int)dataObj << endl;
212	cout << "DBG:: pInfo->mOfs value is " << (int)pInfo->mOfs << endl;
213	cout << "DBG:: d+pInfo->mOfs is " << (int)((char*)dataObj + pInfo->mOfs) << endl;
214	cout << "DBG:: pInfo->mName is " << pInfo->mName << endl;
215	cout << "DBG:: pInfo->mType is " << pInfo->mType << endl;
216	cout << "DBG:: end of dump. " << endl;
217
218	cout << "DBG:: cs value is " << endl << cs << endl;
219	#endif
220	stm.WriteBytes( cs, strlen(cs) );
221	break;
222	}
223
224	case TVAR_DOUBLE :
225	{
226	sprintf( buf, "%f",
227	( (double)( (char*)dataObj+pInfo->mOfs) ) );
228
229	stm.WriteBytes( buf, strlen(buf ) );
230	break;
231	}
232
233	case TVAR_REF_ARRAY :
234	{
235	TArrayInfo& info = ((TArrayInfo)pInfo);
236
237	int sz = ((int) ( (char*)dataObj+info.mSizeIntOfs ));
238	if ( !sz )
239	{
240	// DBG::
241	int u;
242	++u;
243	break;
244	}
245
246	int* array = ((int)( (char)dataObj+info.mRefOfs ));
247
248	ScriptTemplate* pRefTempl;
249
250	for( int i = 0; i != sz; ++i )
251	{
252	pRefTempl =
253	((ScriptTemplate)((char)(array[i])+info.mObjRefTemplOfs));
254
255	pRefTempl->PrintScript( (void*)array[i], stm );
256	}
257
258	break;
259	}
260
261	default : break;
262	}
263	}
264
265	void ScriptTemplate::PrintScript( void* dataObj, ScriptStream& stm )
266	{
267	char* cur = mTText;
268
269	// template parsing loop
270	do
271	{
272	char* start = cur;
273
274	while( cur != '\0' && cur != '$' ) ++cur;
275
276	// flush text collected between variables
277	stm.WriteBytes( start, cur - start );
278
279	if ( *cur == '\0' ) break;
280
281	cur += 2; // skip to the name of the var
282
283	start = cur;
284
285	while( *cur != ')' ) ++cur;
286
287	// put terminating zero temorarely
288
289	*cur = '\0';
290
291	// look up variable
292
293	size_t sz = mVars.size();
294	bool found = 0;
295
296	for( size_t i = 0; i != sz; ++i )
297	{
298	if ( strcmp( mVars[i]->mName, start ) == 0 )
299	{
300	PrintVar( mVars[i], dataObj, stm );
301
302	*cur = ')'; // remove terminating zero
303	++cur;
304	found = 1;
305	break;
306	}
307	}
308
309	// variable referred by template script is not
310	// registered to this tempalte object
311	ASSERT( found );
312
313	} while(1);
314	}
315
316	/*** implementation for class ScriptSection ***/
317
318	int ScriptSection::mIdCounter = 0;
319
320	ScriptSection::ScriptSection( const string& name,
321	const string& body,
322	ScriptTemplate* pSectionTemplate,
323	ScriptTemplate* pReferenceTemplate,
324	bool autoHide,
325	bool sorted
326	)
327	: mpParent ( NULL ),
328
329	mName ( name ),
330	mBody ( body ),
331
332	mAutoHide( autoHide ),
333	mSortOn ( sorted ),
334
335	mpSectTempl( pSectionTemplate ),
336	mpRefTempl ( pReferenceTemplate ),
337
338	mRefCount( 0 ),
339	mArrSize( 0 )
340	{
341	// generate GUID
342
343	char buf[32];
344	sprintf( buf, "%d", ++mIdCounter );
345	mId = buf;
346	}
347
348	ScriptSection::~ScriptSection()
349	{
350	SectListT lst = mSubsections;
351
352	while( mSubsections.size() )
353
354	mSubsections[0]->RemoveRef();
355
356	for( size_t i = 0; i != mReferences.size(); ++i )
357
358	mReferences[i]->RemoveRef();
359	}
360
361	void ScriptSection::AddRef()
362	{
363	++mRefCount;
364	}
365
366	void ScriptSection::RemoveRef()
367	{
368	if ( !mRefCount \|\| !(--mRefCount) )
369	{
370	if (mpParent)
371	{
372	// remove ourselves from parent's list
373
374	SectListT& lst = mpParent->mSubsections;
375	for( size_t i = 0; i != lst.size(); ++i )
376
377	if ( lst[i] == this )
378	{
379	lst.erase( &lst[i] );
380	break;
381	}
382	}
383
384	delete this;
385	}
386	}
387
388	ScriptSection* ScriptSection::GetSubsection( const char* name )
389	{
390	// FOR NOW:: fixed section name length
391	char buf[128];
392
393	size_t cur = 0;
394
395	while( name[cur] && name[cur] != '/' )
396	{
397	buf[cur] = name[cur];
398	++cur;
399	}
400
401	ASSERT( cur < sizeof(buf) );
402
403	buf[cur] = '\0';
404
405	size_t sz = mSubsections.size();
406
407	for( size_t i = 0; i != sz; ++i )
408	{
409	// DBG::
410	//ScriptSection& sect = *mSubsections[i];
411
412	if ( mSubsections[i]->mName == buf )
413	{
414	if ( name[cur] == '/' )
415
416	// search recursivelly
417	return mSubsections[i]->GetSubsection( &name[cur+1] );
418	else
419	return mSubsections[i];
420	}
421	}
422
423	return 0;
424	}
425
426	void ScriptSection::AddSection( ScriptSection* pSection,
427	bool addToReferencesToo
428	)
429	{
430	mSubsections.push_back( pSection );
431
432	pSection->AddRef();
433
434	// can add section to multiple containers
435	ASSERT( pSection->mpParent == 0 );
436
437	pSection->mpParent = this;
438
439	if ( addToReferencesToo )
440
441	AddReference( pSection );
442	}
443
444	void ScriptSection::AddReference( ScriptSection* pReferredSection )
445	{
446	mReferences.push_back( pReferredSection );
447
448	pReferredSection->AddRef();
449
450	// set up mandatory fields used by ScriptTemplate
451	mArrSize = mReferences.size();
452	if ( mArrSize )
453	mRefFirst = (void*)&mReferences[0];
454	}
455
456	SectListT& ScriptSection::GetSubsections()
457	{
458	return mSubsections;
459	}
460
461	// static method:
462	void ScriptSection::RegisterTemplate( ScriptTemplate& sectionTempalte )
463	{
464	int nameOfs, bodyOfs, idOfs,
465	arrRefOfs, arrSizeOfs, refTemplOfs;
466
467	// obtaining offsets of member vars
468
469	GET_VAR_OFS( ScriptSection, mName, &nameOfs )
470	GET_VAR_OFS( ScriptSection, mBody, &bodyOfs )
471	GET_VAR_OFS( ScriptSection, mId, &idOfs )
472	GET_VAR_OFS( ScriptSection, mRefFirst, &arrRefOfs )
473	GET_VAR_OFS( ScriptSection, mArrSize, &arrSizeOfs )
474
475	GET_VAR_OFS( ScriptSection, mpRefTempl, &refTemplOfs )
476
477	// registering member variables with given script template
478
479	sectionTempalte.AddStringVar( "NAME", nameOfs );
480	sectionTempalte.AddStringVar( "BODY", bodyOfs );
481	sectionTempalte.AddStringVar( "ID", idOfs );
482
483	sectionTempalte.AddObjectRefArray( "REFLIST",
484	arrRefOfs, arrSizeOfs, refTemplOfs );
485	}
486
487	void ScriptSection::Print( ScriptStream& stm )
488	{
489	// TBD:: sorting
490
491	// print out this content first
492	if ( mpSectTempl )
493
494	mpSectTempl->PrintScript( this, stm );
495
496	// attach contents subsections at the end of this content
497
498	for( size_t i = 0; i != mSubsections.size(); ++i )
499
500	mSubsections[i]->Print( stm );
501	}
502
503	void ScriptSection::DoRemoveEmptySections(int& nRemoved, SectListT& removedLst)
504	{
505	for( size_t i = 0; i != mSubsections.size(); ++i )
506	{
507	ScriptSection& sect = *mSubsections[i];
508
509	sect.DoRemoveEmptySections( nRemoved, removedLst );
510
511	if (sect.mAutoHide )
512
513	if ( sect.mReferences.size() == 0 )
514	{
515	bool found = 0;
516	for( size_t k = 0; k != removedLst.size(); ++k )
517
518	if ( removedLst[k] == &sect )
519	{
520	found = 1;
521	break;
522	}
523
524	if ( !found )
525	{
526	removedLst.push_back( &sect );
527	++nRemoved;
528
529	delete §
530	--i;
531	}
532	}
533	}
534	}
535
536	void ScriptSection::DoRemoveDeadLinks( SectListT& removedLst)
537	{
538	size_t dsz = removedLst.size();
539
540	for( size_t i = 0; i != mSubsections.size(); ++i )
541	{
542	mSubsections[i]->DoRemoveDeadLinks( removedLst );
543	}
544
545	for( size_t n = 0; n != mReferences.size(); ++n )
546	{
547	for( size_t k = 0; k != dsz; ++k )
548
549	if ( removedLst[k] == mReferences[n] )
550	{
551	mReferences.erase( &mReferences[n] );
552	--n;
553
554	// set up mandatory fields used by ScriptTemplate
555	mArrSize = mReferences.size();
556	if ( mArrSize )
557	mRefFirst = (void*)&mReferences[0];
558
559	break;
560	}
561	}
562	}
563
564
565	void ScriptSection::RemoveEmptySections()
566	{
567	// FIXME:: this is very_very_very slow alg.! +"doesn't work"
568
569	int nRemoved = 0;
570
571	do
572	{
573	SectListT removedLst;
574	nRemoved = 0;
575
576	DoRemoveEmptySections( nRemoved, removedLst );
577
578	DoRemoveDeadLinks( removedLst );
579	}
580	while( nRemoved );
581	}
582
583	/*** Iimplementation for class DocGeneratorBase ***/
584
585	bool DocGeneratorBase::SaveDocument( const char* fname,
586	const char* fopenOptions,
587	ScriptSection* pFromSection
588	)
589	{
590	FILE* fp = fopen( fname, fopenOptions );
591
592	if ( (int)fp == -1 ) return 0;
593
594	ScriptStream stm;
595
596	// check if derived class agrees about saving it
597	if ( !OnSaveDocument( stm ) ) return 0;
598
599	if ( pFromSection )
600
601	pFromSection->Print( stm );
602	else
603	{
604	ScriptSection* pTopSect = GetTopSection();
605	ASSERT( pTopSect );
606	pTopSect->Print( stm );
607	}
608
609	size_t nWrite = fwrite( stm.GetBuf(), 1, stm.GetBufSize(), fp );
610
611	if ( nWrite != stm.GetBufSize() ) return 0;
612
613	fclose( fp );
614
615	return 1;
616
617	// that^s it
618	}