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

#ifndef __DARWIN__
#  include <malloc.h>
#endif
#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]->m_Name, 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->m_Name is " << pInfo->m_Name << 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 = 0;
                    ++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 = false;

        for( size_t i = 0; i != sz; ++i )
        {
            if ( strcmp( mVars[i]->m_Name, 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 ),

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