autodoc/source/display/html/hdimpl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: hdimpl.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <precomp.h>
  32 #include "hdimpl.hxx"
  33
  34
  35 // NOT FULLY DEFINED SERVICES
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <ary/ceslot.hxx>
  39 #include <ary/qualiname.hxx>
  40 #include <ary/cpp/c_class.hxx>
  41 #include <ary/cpp/c_de.hxx>
  42 #include <ary/cpp/c_enum.hxx>
  43 #include <ary/cpp/c_funct.hxx>
  44 #include <ary/cpp/c_gate.hxx>
  45 #include <ary/cpp/cp_ce.hxx>
  46 #include <udm/html/htmlitem.hxx>
  47 #include "cre_link.hxx"
  48 #include "hd_docu.hxx"
  49 #include "html_kit.hxx"
  50 #include "opageenv.hxx"
  51 #include "pagemake.hxx"
  52 #include "strconst.hxx"
  53
  54
  55 using namespace csi;
  56
  57
  58 //********************       HtmlDisplay_Impl        *********************//
  59
  60 HtmlDisplay_Impl::~HtmlDisplay_Impl()
  61 {
  62 }
  63
  64 HtmlDisplay_Impl::HtmlDisplay_Impl( OuputPage_Environment & io_rEnv )
  65     :   pEnv(&io_rEnv)
  66         // aWriteHelper
  67 {
  68 }
  69
  70
  71 //********************       Free Functions        *********************//
  72
  73
  74
  75 namespace dshelp
  76 {
  77
  78 void
  79 DisplaySlot( ary::Display &          o_rDisplay,
  80              const ary::AryGroup &   i_rGroup,
  81              ary::SlotAccessId       i_nSlot )
  82 {
  83      ary::Slot_AutoPtr pSlot( i_rGroup.Create_Slot(i_nSlot) );
  84     pSlot->StoreAt( o_rDisplay );
  85 }
  86
  87
  88 const char *
  89 PathUp( uintt i_nLevels )
  90 {
  91     static char sResult[300];
  92
  93     sResult[0] = NULCH;
  94     for ( uintt lev = 0; lev < i_nLevels; ++lev )
  95     {
  96         strcat( sResult, "../");        // SAFE STRCAT (#100211# - checked)
  97     }
  98     return sResult;
  99 }
 100
 101 const char *
 102 PathPerLevelsUp( uintt                   i_nLevels,
 103                  const char *            i_nPathBelowDestinationLevel )
 104 {
 105     static char sResult[500];
 106     strcpy( sResult, PathUp(i_nLevels) );               // SAFE STRCPY (#100211# - checked)
 107     // KORR_FUTURE: Make it still safer here:
 108     strcat( sResult, i_nPathBelowDestinationLevel );    // SAFE STRCAT (#100211# - checked)
 109     return sResult;
 110 }
 111
 112
 113 const char *
 114 PathPerRoot( const OuputPage_Environment & i_rEnv,
 115              const char *                  i_sPathFromRootDir )
 116 {
 117     return PathPerLevelsUp( i_rEnv.Depth(), i_sPathFromRootDir );
 118 }
 119
 120 const char *
 121 PathPerNamespace( const OuputPage_Environment & i_rEnv,
 122                   const char *                  i_sPathFromNamespaceDir )
 123 {
 124     const ary::cpp::Namespace * pNsp = i_rEnv.CurNamespace();
 125     if ( pNsp == 0 )
 126         return "";
 127
 128     uintt nCount = i_rEnv.Depth() - (pNsp->Depth() + 1) ;
 129     csv_assert( nCount < 100 );
 130     return PathPerLevelsUp( nCount, i_sPathFromNamespaceDir );
 131 }
 132
 133 const char *
 134 HtmlFileName( const char *            i_sPrefix,
 135               const char *            i_sEntityName )
 136 {
 137     // KORR_FUTURE: Make it still safer here:
 138     static char sResult[300];
 139     strcpy( sResult, i_sPrefix );       // SAFE STRCPY (#100211# - checked)
 140     strcat( sResult, i_sEntityName );   // SAFE STRCAT (#100211# - checked)
 141     strcat( sResult, ".html" );         // SAFE STRCAT (#100211# - checked)
 142     return sResult;
 143 }
 144
 145 const char *
 146 Path2Class( uintt                   i_nLevelsUp,
 147             const char *            i_sClassLocalName )
 148 {
 149     return PathPerLevelsUp( i_nLevelsUp, ClassFileName(i_sClassLocalName) );
 150 }
 151
 152 const char *
 153 Path2Child( const char *            i_sFileName,
 154             const char *            i_sSubDir )
 155 {
 156     static char sResult[400];
 157     if ( i_sSubDir != 0 )
 158     {
 159         // KORR_FUTURE: Make it still safer here:
 160         strcpy( sResult, i_sSubDir );       // SAFE STRCPY (#100211# - checked)
 161         strcat( sResult, "/" );             // SAFE STRCAT (#100211# - checked)
 162     }
 163     else
 164     {
 165         sResult[0] = NULCH;
 166     }
 167
 168     strcat( sResult, i_sFileName );         // SAFE STRCAT (#100211# - checked)
 169     return sResult;
 170 }
 171
 172 const char *
 173 Path2ChildNamespace( const char * i_sLocalName )
 174 {
 175     return Path2Child( C_sHFN_Namespace, i_sLocalName );
 176 }
 177
 178 String
 179 OperationLink( const ary::cpp::Gate &               ,
 180                const String  &                      i_sOpName,
 181                ary::cpp::Ce_id                      i_nOpId,
 182                const char *                         i_sPrePath )
 183 {
 184     StreamLock
 185         slResult(3000);
 186     StreamStr &
 187         sResult = slResult();
 188
 189     sResult
 190         << i_sPrePath
 191         << "#"
 192         << i_sOpName
 193         << "-"
 194         << i_nOpId.Value();
 195
 196
 197
 198     return sResult.c_str();
 199 }
 200
 201 const char *
 202 DataLink( const String  &         i_sLocalName,
 203           const char *            i_sPrePath )
 204 {
 205     StreamLock
 206         slResult(3000);
 207     StreamStr &
 208         sResult = slResult();
 209
 210     sResult
 211         << i_sPrePath
 212         << "#"
 213         << i_sLocalName;
 214
 215     return sResult.c_str();
 216 }
 217
 218 void
 219 Get_LinkedTypeText( csi::xml::Element &             o_rOut,
 220                     const OuputPage_Environment &   i_rEnv,
 221                     ary::cpp::Type_id               i_nId,
 222                     bool                            i_bWithAbsolutifier )
 223 {
 224     if (NOT i_nId.IsValid())
 225         return;
 226
 227      const char * sPreName = "";
 228      const char * sName = "";
 229      const char * sPostName = "";
 230
 231     bool bTypeExists = Get_TypeText( sPreName,
 232                                      sName,
 233                                      sPostName,
 234                                      i_nId,
 235                                      i_rEnv.Gate() );
 236     if ( NOT bTypeExists )
 237         return;
 238
 239     if ( NOT i_bWithAbsolutifier AND strncmp(sPreName,"::",2) == 0 )
 240         sPreName+=2;
 241
 242     const ary::cpp::CodeEntity *
 243         pCe = i_rEnv.Gate().Search_RelatedCe(i_nId);
 244
 245     String  sLink;
 246     if ( pCe != 0 )
 247     {
 248         sLink = Link2Ce(i_rEnv,*pCe);
 249     }
 250     else
 251     {
 252         if ( strstr(sPreName,"com::sun::star") != 0 )
 253         {
 254             static StreamStr aLink(400);
 255             aLink.seekp(0);
 256             aLink << PathPerRoot(i_rEnv, "../../common/ref");
 257             if ( *sPreName != ':' )
 258                 aLink << '/';
 259             for ( const char * s = sPreName;
 260                   *s != 0;
 261                   ++s )
 262             {
 263                 if ( *s == ':' )
 264                 {
 265                      aLink << '/';
 266                     ++s;
 267                 }
 268                 else
 269                 {
 270                      aLink << *s;
 271                 }
 272             }   // end for
 273             aLink << sName
 274                   << ".html";
 275             sLink = aLink.c_str();
 276         }
 277     }   // endif( pCe != 0 )
 278
 279     o_rOut
 280         << sPreName;
 281     csi::xml::Element &
 282         o_Goon = sLink.length() > 0
 283                      ?   o_rOut >> * new html::Link( sLink.c_str() )
 284                      :   o_rOut;
 285     o_Goon
 286         <<  sName;
 287     o_rOut
 288         << sPostName;
 289 }
 290
 291 void
 292 Create_ChildListLabel( csi::xml::Element &     o_rParentElement,
 293                        const char *            i_sLabel )
 294 {
 295     if ( NOT csv::no_str(i_sLabel) )
 296     {
 297         o_rParentElement
 298             >> *new html::Label(i_sLabel)
 299                     << " ";
 300     }
 301 }
 302
 303 DYN csi::html::Table &
 304 Create_ChildListTable( const char * i_sTitle )
 305 {
 306     html::Table *
 307             dpTable = new html::Table;
 308     *dpTable
 309         << new html::ClassAttr( "childlist")
 310         << new xml::AnAttribute( "border", "1" )
 311         << new xml::AnAttribute( "cellpadding", "5" )
 312         << new xml::AnAttribute( "cellspacing", "0" )
 313         << new html::WidthAttr( "100%" );
 314
 315     html::TableRow &
 316             rRow = dpTable->AddRow();
 317     rRow
 318         << new html::ClassAttr("subtitle")
 319         >> *new html::TableCell
 320                 << new xml::AnAttribute( "colspan","2" )
 321                 >> *new html::Headline(4)
 322                         << i_sTitle;
 323     return *dpTable;
 324 }
 325
 326 const char *
 327 Link2Ce( const OuputPage_Environment & i_rEnv,
 328          const ary::cpp::CodeEntity &  i_rCe )
 329 {
 330     const uintt         nMaxSize
 331                             = 3000;
 332     static char         sLink[nMaxSize];
 333     static LinkCreator  aLinkCreator( &sLink[0], nMaxSize );
 334     sLink[0] = NULCH;
 335
 336     aLinkCreator.SetEnv(i_rEnv);
 337     i_rCe.Accept(aLinkCreator);
 338
 339     return sLink;
 340 }
 341
 342 const char *
 343 Link2CppDefinition( const OuputPage_Environment & i_rEnv,
 344                     const ary::cpp::DefineEntity &    i_rDef )
 345 {
 346     const uintt         nMaxSize
 347                             = 1000;
 348     static char         sLink[nMaxSize];
 349     static LinkCreator  aLinkCreator( &sLink[0], nMaxSize );
 350     sLink[0] = NULCH;
 351
 352     aLinkCreator.SetEnv(i_rEnv);
 353     i_rDef.Accept(aLinkCreator);
 354
 355     return sLink;
 356 }
 357
 358 const ary::cpp::CodeEntity *
 359 FindUnambiguousCe( const OuputPage_Environment & i_rEnv,
 360                    const ary::QualifiedName &    i_rQuName,
 361                    const ary::cpp::Class *       i_pJustDocumentedClass )
 362 {
 363      if ( i_rEnv.CurNamespace() == 0 )
 364         return 0;
 365
 366     const ary::cpp::CodeEntity * ret = 0;
 367
 368     if ( NOT i_rQuName.IsQualified() )
 369     {
 370         if ( i_pJustDocumentedClass != 0 )
 371             ret = i_rEnv.Gate().Ces().Search_CeLocal( i_rQuName.LocalName(),
 372                                                       i_rQuName.IsFunction(),
 373                                                       *i_rEnv.CurNamespace(),
 374                                                       i_pJustDocumentedClass );
 375         if (ret != 0)
 376             return ret;
 377
 378         ret = i_rEnv.Gate().Ces().Search_CeLocal( i_rQuName.LocalName(),
 379                                                   i_rQuName.IsFunction(),
 380                                                   *i_rEnv.CurNamespace(),
 381                                                   i_rEnv.CurClass() );
 382     }
 383     if (ret != 0)
 384         return ret;
 385
 386     return i_rEnv.Gate().Ces().Search_CeAbsolute( *i_rEnv.CurNamespace(),
 387                                                   i_rQuName );
 388 }
 389
 390 void
 391 ShowDocu_On( csi::xml::Element &            o_rOut,
 392              Docu_Display &                 io_rDisplay,
 393              const ary::cpp::CppEntity &    i_rRE )
 394 {
 395     if (i_rRE.Docu().Data() != 0)
 396     {
 397         io_rDisplay.Assign_Out( o_rOut );
 398         io_rDisplay.Process(i_rRE.Docu());
 399         io_rDisplay.Unassign_Out();
 400     }
 401 }
 402
 403 void
 404 WriteOut_TokenList( csi::xml::Element &     o_rOut,
 405                     const StringVector &    i_rTokens,
 406                     const char *            i_sSeparator )
 407 {
 408     if ( i_rTokens.size() > 0 )
 409     {
 410         StringVector::const_iterator
 411             it      = i_rTokens.begin();
 412         StringVector::const_iterator
 413             itEnd   = i_rTokens.end();
 414
 415         o_rOut << *it;
 416         for ( ++it; it != itEnd; ++it )
 417         {
 418             o_rOut << i_sSeparator << *it;
 419         }
 420     };
 421
 422 }
 423
 424 void
 425 EraseLeadingSpace( String  & io_rStr )
 426 {
 427     if ( *io_rStr.c_str() < 33 AND io_rStr.length() > 0 )
 428     {
 429         const unsigned char * pNew;
 430         for ( pNew = (const unsigned char * ) io_rStr.c_str();
 431               *pNew < 33 AND *pNew != 0;
 432               ++pNew ) {}
 433         String  sNew( (const char*)pNew );
 434         io_rStr = sNew;
 435     }
 436 }
 437
 438 void
 439 WriteOut_LinkedFunctionText( csi::xml::Element &            o_rTitleOut,
 440                              adcdisp::ParameterTable &      o_rParameters,
 441                              const ary::cpp::Function &     i_rFunction,
 442                              const OuputPage_Environment &  i_rEnv,
 443                              bool *                         o_bIsConst,
 444                              bool *                         o_bIsVirtual )
 445 {
 446     // write pre-name:
 447     const ary::cpp::FunctionFlags & rFlags = i_rFunction.Flags();
 448     if ( rFlags.IsStaticLocal() OR rFlags.IsStaticMember() )
 449         o_rTitleOut << "static ";
 450     if ( rFlags.IsExplicit() )
 451         o_rTitleOut << "explicit ";
 452     if ( rFlags.IsMutable() )
 453         o_rTitleOut << "mutable ";
 454     if ( i_rFunction.Virtuality() != ary::cpp::VIRTUAL_none )
 455         o_rTitleOut << "virtual ";
 456 //    o_rTitleOut << new html::LineBreak;
 457
 458     Get_LinkedTypeText( o_rTitleOut, i_rEnv, i_rFunction.ReturnType() );
 459
 460     // write name:
 461     o_rTitleOut
 462         << " "
 463         >> *new html::Strong
 464             << i_rFunction.LocalName();
 465     o_rTitleOut
 466             << "(";
 467
 468
 469     csi::xml::Element * pOutLast = &o_rTitleOut;
 470
 471     // write post-name:
 472     FunctionParam_Iterator fit;
 473     fit.Assign(i_rFunction);
 474
 475     if (fit)
 476     {
 477         o_rParameters.AddEntry();
 478         Get_LinkedTypeText( o_rParameters.Type(), i_rEnv, fit.CurType() );
 479         o_rParameters.Type() << " ";
 480         o_rParameters.Name() << " " << fit.CurName();
 481
 482         for ( ++fit; fit; ++fit )
 483         {
 484             o_rParameters.Name() << ",";
 485             o_rParameters.AddEntry();
 486             Get_LinkedTypeText( o_rParameters.Type(), i_rEnv, fit.CurType() );
 487             o_rParameters.Name() << fit.CurName();
 488         }
 489
 490         pOutLast = &o_rParameters.Name();
 491         o_rParameters.Name() << " ";
 492     }
 493
 494     *pOutLast  << ")";
 495     if ( fit.IsFunctionConst() )
 496     {
 497         *pOutLast << " const";
 498         if ( o_bIsConst != 0 )
 499             *o_bIsConst = true;
 500     }
 501     if ( fit.IsFunctionVolatile() )
 502     {
 503         *pOutLast << " volatile";
 504         if ( o_bIsVirtual != 0 )
 505             *o_bIsVirtual = true;
 506     }
 507
 508     // write Exceptions:
 509     const std::vector< ary::cpp::Type_id > *
 510             pThrow = i_rFunction.Exceptions();
 511     if ( pThrow)
 512     {
 513         std::vector< ary::cpp::Type_id >::const_iterator
 514                 it = pThrow->begin();
 515         std::vector< ary::cpp::Type_id >::const_iterator
 516                 it_end = pThrow->end();
 517
 518         if (it != it_end)
 519         {
 520             o_rParameters.AddEntry();
 521             pOutLast = &o_rParameters.Name();
 522
 523             o_rParameters.Name() << " throw( ";
 524             Get_LinkedTypeText(o_rParameters.Name(), i_rEnv, *it);
 525
 526             for ( ++it; it != it_end; ++it )
 527             {
 528                 o_rParameters.Name() << ", ";
 529                 Get_LinkedTypeText(o_rParameters.Name(), i_rEnv, *it);
 530             }
 531             o_rParameters.Name() << " )";
 532         }
 533         else
 534         {
 535             *pOutLast << " throw()";
 536         }
 537     }   // endif // pThrow
 538
 539     // abstractness:
 540     if ( i_rFunction.Virtuality() == ary::cpp::VIRTUAL_abstract )
 541         *pOutLast << " = 0";
 542
 543     // finish:
 544     *pOutLast << ";";
 545 }
 546
 547
 548
 549 }   // namespace dshelp