utils/HelpGen/src/scriptbinder.cpp

   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]->mName, 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->mName is " << pInfo->mName << 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 = 0;
 297
 298                 for( size_t i = 0; i != sz; ++i )
 299                 {
 300                         if ( strcmp( mVars[i]->mName, 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           mName    ( 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]->mName == 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, mName,     &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 = 0;
 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 &sect;
 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 ( (int)fp == -1 ) 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 }