autodoc/source/parser_i/idoc/docu_pe2.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: docu_pe2.cxx,v $
  10  * $Revision: 1.15 $
  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 <s2_dsapi/docu_pe2.hxx>
  33
  34
  35 // NOT FULLY DEFINED SERVICES
  36 #include <ary/doc/d_oldidldocu.hxx>
  37 #include <ary_i/d_token.hxx>
  38 #include <parser/parserinfo.hxx>
  39 #include <adc_cl.hxx>
  40 #include <adc_msg.hxx>
  41 #include <../parser/inc/x_docu.hxx>
  42 #include <s2_dsapi/dsapitok.hxx>
  43 #include <s2_dsapi/tk_atag2.hxx>
  44 #include <s2_dsapi/tk_html.hxx>
  45 #include <s2_dsapi/tk_docw2.hxx>
  46 #include <s2_dsapi/tk_xml.hxx>
  47
  48
  49 #ifdef UNX
  50 #define strnicmp strncasecmp
  51 #endif
  52
  53
  54 namespace csi
  55 {
  56 namespace dsapi
  57 {
  58
  59
  60 const char *            AtTagTitle(
  61                         const Tok_AtTag &       i_rToken );
  62
  63
  64 SapiDocu_PE::SapiDocu_PE(ParserInfo & io_rPositionInfo)
  65     :   pDocu(0),
  66         eState(e_none),
  67         pPositionInfo(&io_rPositionInfo),
  68         fCurTokenAddFunction(&SapiDocu_PE::AddDocuToken2Void),
  69         pCurAtTag(0),
  70         sCurDimAttribute(),
  71         sCurAtSeeType_byXML(200)
  72 {
  73 }
  74
  75 SapiDocu_PE::~SapiDocu_PE()
  76 {
  77 }
  78
  79 void
  80 SapiDocu_PE::ProcessToken( DYN csi::dsapi::Token & let_drToken )
  81 {
  82     if (IsComplete())
  83     {
  84         pDocu = 0;
  85         eState = e_none;
  86     }
  87
  88     if ( eState == e_none )
  89     {
  90         pDocu = new ary::doc::OldIdlDocu;
  91         eState = st_short;
  92         fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2Short;
  93     }
  94
  95     csv_assert(pDocu);
  96
  97     let_drToken.Trigger(*this);
  98     delete &let_drToken;
  99 }
 100
 101 void
 102 SapiDocu_PE::Process_AtTag(     const Tok_AtTag & i_rToken )
 103 {
 104     if (NOT pCurAtTag)
 105     {
 106         eState = st_attags;
 107         fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2CurAtTag;
 108     }
 109     else
 110     {
 111         csv_assert(eState == st_attags);
 112         pDocu->AddAtTag(*pCurAtTag.Release());
 113     }
 114
 115     if (i_rToken.Id() == Tok_AtTag::param)
 116     {
 117         pCurAtTag = new DT_ParameterAtTag;
 118         fCurTokenAddFunction = &SapiDocu_PE::SetCurParameterAtTagName;
 119     }
 120     else if (i_rToken.Id() == Tok_AtTag::see)
 121     {
 122         pCurAtTag = new DT_SeeAlsoAtTag;
 123         fCurTokenAddFunction = &SapiDocu_PE::SetCurSeeAlsoAtTagLinkText;
 124     }
 125     else if (i_rToken.Id() == Tok_AtTag::deprecated)
 126     {
 127         pDocu->SetDeprecated();
 128         pCurAtTag = new DT_StdAtTag("");    // Dummy that will not be used.
 129         fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2Deprecated;
 130     }
 131     else if (i_rToken.Id() == Tok_AtTag::since)
 132     {
 133         pCurAtTag = new DT_SinceAtTag;
 134         fCurTokenAddFunction = &SapiDocu_PE::SetCurSinceAtTagVersion;
 135     }
 136     else
 137     {
 138         pCurAtTag = new DT_StdAtTag( AtTagTitle(i_rToken) );
 139         fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2CurAtTag;
 140     }
 141 }
 142
 143 void
 144 SapiDocu_PE::Process_HtmlTag( const Tok_HtmlTag & i_rToken )
 145 {
 146     if (eState == st_short AND i_rToken.IsParagraphStarter())
 147     {
 148         eState = st_description;
 149         fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2Description;
 150     }
 151
 152     // Workaround special for some errors in API docu:
 153     if ( strnicmp("<true",i_rToken.Text(),5 ) == 0 )
 154     {
 155         if ( strcmp("<TRUE/>",i_rToken.Text()) != 0 )
 156             TheMessages().Out_InvalidConstSymbol( i_rToken.Text(),
 157                                               pPositionInfo->CurFile(),
 158                                               pPositionInfo->CurLine() );
 159         (this->*fCurTokenAddFunction)( *new DT_TextToken("<b>true</b>") );
 160         return;
 161     }
 162     else if ( strnicmp("<false",i_rToken.Text(),6 ) == 0 )
 163     {
 164         if ( strcmp("<FALSE/>",i_rToken.Text()) != 0 )
 165             TheMessages().Out_InvalidConstSymbol( i_rToken.Text(),
 166                                               pPositionInfo->CurFile(),
 167                                               pPositionInfo->CurLine() );
 168         (this->*fCurTokenAddFunction)( *new DT_TextToken("<b>false</b>") );
 169         return;
 170     }
 171     else if ( strnicmp("<NULL",i_rToken.Text(),5 ) == 0 )
 172     {
 173         if ( strcmp("<NULL/>",i_rToken.Text()) != 0 )
 174             TheMessages().Out_InvalidConstSymbol( i_rToken.Text(),
 175                                               pPositionInfo->CurFile(),
 176                                               pPositionInfo->CurLine() );
 177         (this->*fCurTokenAddFunction)( *new DT_TextToken("<b>null</b>") );
 178         return;
 179     }
 180     else if ( strnicmp("<void",i_rToken.Text(),5 ) == 0 )
 181     {
 182         if ( strcmp("<void/>",i_rToken.Text()) != 0 )
 183             TheMessages().Out_InvalidConstSymbol( i_rToken.Text(),
 184                                               pPositionInfo->CurFile(),
 185                                               pPositionInfo->CurLine() );
 186         (this->*fCurTokenAddFunction)( *new DT_TextToken("<b>void</b>") );
 187         return;
 188     }
 189
 190     (this->*fCurTokenAddFunction)( *new DT_Style(i_rToken.Text(),false) );
 191 }
 192
 193 void
 194 SapiDocu_PE::Process_XmlConst( const Tok_XmlConst & i_rToken )
 195 {
 196     (this->*fCurTokenAddFunction)(*new DT_MupConst(i_rToken.Text()));
 197 }
 198
 199 void
 200 SapiDocu_PE::Process_XmlLink_BeginTag( const Tok_XmlLink_BeginTag & i_rToken )
 201 {
 202     switch (i_rToken.Id())
 203     {
 204         case Tok_XmlLink_Tag::e_const:
 205             (this->*fCurTokenAddFunction)(*new DT_Style("<b>",false));
 206             break;
 207         case Tok_XmlLink_Tag::member:
 208             (this->*fCurTokenAddFunction)(*new DT_MupMember(i_rToken.Scope()));
 209             break;
 210         case Tok_XmlLink_Tag::type:
 211             (this->*fCurTokenAddFunction)(*new DT_MupType(i_rToken.Scope()));
 212             break;
 213         default:
 214             //  Do nothing.
 215             ;
 216     }
 217
 218     if ( i_rToken.Dim().length() > 0 )
 219         sCurDimAttribute = i_rToken.Dim();
 220     else
 221         sCurDimAttribute.clear();
 222 }
 223
 224 void
 225 SapiDocu_PE::Process_XmlLink_EndTag( const Tok_XmlLink_EndTag & i_rToken )
 226 {
 227     switch (i_rToken.Id())
 228     {
 229         case Tok_XmlLink_Tag::e_const:
 230             (this->*fCurTokenAddFunction)(*new DT_Style("</b>",false));
 231             break;
 232         case Tok_XmlLink_Tag::member:
 233             (this->*fCurTokenAddFunction)(*new DT_MupMember(true));
 234             break;
 235         case Tok_XmlLink_Tag::type:
 236             (this->*fCurTokenAddFunction)(*new DT_MupType(true));
 237             break;
 238         default:
 239             //  Do nothing.
 240             ;
 241     }
 242     if ( sCurDimAttribute.length() > 0 )
 243     {
 244         (this->*fCurTokenAddFunction)( *new DT_TextToken(sCurDimAttribute.c_str()) );
 245         sCurDimAttribute.clear();
 246     }
 247 }
 248
 249 void
 250 SapiDocu_PE::Process_XmlFormat_BeginTag( const Tok_XmlFormat_BeginTag & i_rToken )
 251 {
 252     switch (i_rToken.Id())
 253     {
 254         case Tok_XmlFormat_Tag::code:
 255             (this->*fCurTokenAddFunction)(*new DT_Style("<code>",false));
 256             break;
 257         case Tok_XmlFormat_Tag::listing:
 258             (this->*fCurTokenAddFunction)(*new DT_Style("<pre>",true));
 259             break;
 260         case Tok_XmlFormat_Tag::atom:
 261             (this->*fCurTokenAddFunction)(*new DT_Style("<code>",true));
 262             break;
 263         default:
 264             //  Do nothing.
 265             ;
 266     }
 267     if ( i_rToken.Dim().length() > 0 )
 268         sCurDimAttribute = i_rToken.Dim();
 269     else
 270         sCurDimAttribute.clear();
 271 }
 272
 273 void
 274 SapiDocu_PE::Process_XmlFormat_EndTag( const Tok_XmlFormat_EndTag & i_rToken )
 275 {
 276     switch (i_rToken.Id())
 277     {
 278         case Tok_XmlFormat_Tag::code:
 279             (this->*fCurTokenAddFunction)(*new DT_Style("</code>",false));
 280             break;
 281         case Tok_XmlFormat_Tag::listing:
 282             (this->*fCurTokenAddFunction)(*new DT_Style("</pre>",true));
 283             break;
 284         case Tok_XmlFormat_Tag::atom:
 285             (this->*fCurTokenAddFunction)(*new DT_Style("</code>",true));
 286             break;
 287         default:
 288             //  Do nothing.
 289             ;
 290     }
 291     if ( sCurDimAttribute.length() > 0 )
 292     {
 293         (this->*fCurTokenAddFunction)( *new DT_TextToken(sCurDimAttribute.c_str()) );
 294         sCurDimAttribute.clear();
 295     }
 296 }
 297
 298 void
 299 SapiDocu_PE::Process_Word( const Tok_Word &     i_rToken )
 300 {
 301     (this->*fCurTokenAddFunction)(*new DT_TextToken(i_rToken.Text()));
 302 }
 303
 304 void
 305 SapiDocu_PE::Process_Comma()
 306 {
 307     csv_assert(1==7);
 308 //      (this->*fCurTokenAddFunction)(*new DT_Comma(i_rToken.Text()));
 309 }
 310
 311 void
 312 SapiDocu_PE::Process_DocuEnd()
 313 {
 314     eState = st_complete;
 315     if (pCurAtTag)
 316         pDocu->AddAtTag(*pCurAtTag.Release());
 317     fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2Void;
 318 }
 319
 320 void
 321 SapiDocu_PE::Process_EOL()
 322 {
 323     (this->*fCurTokenAddFunction)(*new DT_EOL);
 324 }
 325
 326 void
 327 SapiDocu_PE::Process_White()
 328 {
 329     (this->*fCurTokenAddFunction)(*new DT_White);
 330 }
 331
 332 DYN ary::doc::OldIdlDocu *
 333 SapiDocu_PE::ReleaseJustParsedDocu()
 334 {
 335     if (IsComplete())
 336     {
 337         eState = e_none;
 338         return pDocu.Release();
 339     }
 340     return 0;
 341 }
 342
 343
 344 bool
 345 SapiDocu_PE::IsComplete() const
 346 {
 347     return eState == st_complete;
 348 }
 349
 350 void
 351 SapiDocu_PE::AddDocuToken2Void( DYN ary::inf::DocuToken & let_drNewToken )
 352 {
 353     delete &let_drNewToken;
 354 }
 355
 356 void
 357 SapiDocu_PE::AddDocuToken2Short( DYN ary::inf::DocuToken & let_drNewToken )
 358 {
 359     csv_assert(pDocu);
 360     pDocu->AddToken2Short(let_drNewToken);
 361 }
 362
 363 void
 364 SapiDocu_PE::AddDocuToken2Description( DYN ary::inf::DocuToken & let_drNewToken )
 365 {
 366     csv_assert(pDocu);
 367     pDocu->AddToken2Description(let_drNewToken);
 368 }
 369
 370 void
 371 SapiDocu_PE::AddDocuToken2Deprecated( DYN ary::inf::DocuToken & let_drNewToken )
 372 {
 373     csv_assert(pDocu);
 374     pDocu->AddToken2DeprecatedText(let_drNewToken);
 375 }
 376
 377 void
 378 SapiDocu_PE::AddDocuToken2CurAtTag( DYN ary::inf::DocuToken & let_drNewToken )
 379 {
 380     csv_assert(pCurAtTag);
 381     pCurAtTag->AddToken(let_drNewToken);
 382 }
 383
 384 void
 385 SapiDocu_PE::SetCurParameterAtTagName( DYN ary::inf::DocuToken & let_drNewToken )
 386 {
 387     if (let_drNewToken.IsWhiteOnly())
 388     {
 389         delete &let_drNewToken;
 390         return;
 391     }
 392
 393     csv_assert(pCurAtTag);
 394     DT_TextToken * dpText = dynamic_cast< DT_TextToken* >(&let_drNewToken);
 395     if (dpText != 0)
 396         pCurAtTag->SetName(dpText->GetText());
 397     else
 398         pCurAtTag->SetName("parameter ?");
 399     delete &let_drNewToken;
 400     fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2CurAtTag;
 401 }
 402
 403 void
 404 SapiDocu_PE::SetCurSeeAlsoAtTagLinkText( DYN ary::inf::DocuToken & let_drNewToken )
 405 {
 406     csv_assert(pCurAtTag);
 407
 408     if (let_drNewToken.IsWhiteOnly())
 409     {
 410         delete &let_drNewToken;
 411         return;
 412     }
 413
 414     DT_TextToken * pText = dynamic_cast< DT_TextToken* >(&let_drNewToken);
 415     if (pText != 0)
 416         pCurAtTag->SetName(pText->GetText());
 417     else
 418     {
 419         DT_MupType *
 420             pTypeBegin = dynamic_cast< DT_MupType* >(&let_drNewToken);
 421         DT_MupMember *
 422             pMemberBegin = dynamic_cast< DT_MupMember* >(&let_drNewToken);
 423         if (pTypeBegin != 0 OR pMemberBegin != 0)
 424         {
 425             sCurAtSeeType_byXML.reset();
 426
 427             sCurAtSeeType_byXML
 428                 << ( pTypeBegin != 0
 429                         ?   pTypeBegin->Scope()
 430                         :   pMemberBegin->Scope() );
 431
 432             if (sCurAtSeeType_byXML.tellp() > 0)
 433             {
 434                 sCurAtSeeType_byXML
 435                     << "::";
 436             }
 437             delete &let_drNewToken;
 438             fCurTokenAddFunction = &SapiDocu_PE::SetCurSeeAlsoAtTagLinkText_2;
 439             return;
 440         }
 441         else
 442         {
 443             pCurAtTag->SetName("? (no identifier found)");
 444         }
 445     }
 446     delete &let_drNewToken;
 447     fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2CurAtTag;
 448 }
 449
 450 void
 451 SapiDocu_PE::SetCurSeeAlsoAtTagLinkText_2( DYN ary::inf::DocuToken & let_drNewToken )
 452 {
 453     csv_assert(pCurAtTag);
 454
 455     if (let_drNewToken.IsWhiteOnly())
 456     {
 457         delete &let_drNewToken;
 458         return;
 459     }
 460
 461     DT_TextToken *
 462         pText = dynamic_cast< DT_TextToken* >(&let_drNewToken);
 463     if (pText != 0)
 464     {
 465         sCurAtSeeType_byXML
 466             << pText->GetText();
 467         pCurAtTag->SetName(sCurAtSeeType_byXML.c_str());
 468     }
 469     else
 470     {
 471         pCurAtTag->SetName("? (no identifier found)");
 472     }
 473     sCurAtSeeType_byXML.reset();
 474     delete &let_drNewToken;
 475     fCurTokenAddFunction = &SapiDocu_PE::SetCurSeeAlsoAtTagLinkText_3;
 476 }
 477
 478 void
 479 SapiDocu_PE::SetCurSeeAlsoAtTagLinkText_3( DYN ary::inf::DocuToken & let_drNewToken )
 480 {
 481     csv_assert(pCurAtTag);
 482
 483     if (let_drNewToken.IsWhiteOnly())
 484     {
 485         delete &let_drNewToken;
 486         return;
 487     }
 488
 489     /// Could emit warning, but don't because this parser is obsolete.
 490 //      Tok_XmlLink_BeginTag *
 491 //          pLinkEnd = dynamic_cast< Tok_XmlLink_EndTag* >(&let_drNewToken);
 492 //      if (pLinkEnd == 0)
 493 //      {
 494 //          warn_aboutMissingClosingTag();
 495 //      }
 496
 497     delete &let_drNewToken;
 498     fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2CurAtTag;
 499 }
 500
 501
 502
 503 void
 504 SapiDocu_PE::SetCurSinceAtTagVersion( DYN ary::inf::DocuToken & let_drNewToken )
 505 {
 506     csv_assert(pCurAtTag);
 507
 508     DT_TextToken * pToken = dynamic_cast< DT_TextToken* >(&let_drNewToken);
 509     if (pToken == 0)
 510     {
 511         delete &let_drNewToken;
 512         return;
 513     }
 514
 515     const String
 516         sVersion(pToken->GetText());
 517     const char
 518         cFirst = *sVersion.begin();
 519     const char
 520         cCiphersend = '9' + 1;
 521     const autodoc::CommandLine &
 522         rCommandLine = autodoc::CommandLine::Get_();
 523
 524
 525     if ( rCommandLine.DoesTransform_SinceTag())
 526     {
 527         // The @since version number shall be interpreted,
 528
 529         if ( NOT csv::in_range('0', cFirst, cCiphersend) )
 530         {
 531             // But this is a non-number-part, so we wait for
 532             // the next one.
 533             delete &let_drNewToken;
 534             return;
 535         }
 536         else if (rCommandLine.DisplayOf_SinceTagValue(sVersion).empty())
 537         {
 538             // This is the numbered part, but we don't know it.
 539             delete &let_drNewToken;
 540
 541             StreamLock
 542                 sl(200);
 543             sl()
 544                 << "Since-value '"
 545                 << sVersion
 546                 << "' not found in translation table.";
 547             throw X_Docu("since", sl().c_str());
 548         }
 549     }
 550
 551     // Either since tags are not specially interpreted, or
 552     // we got a known one.
 553     pCurAtTag->AddToken(let_drNewToken);
 554     fCurTokenAddFunction = &SapiDocu_PE::AddDocuToken2SinceAtTag;
 555 }
 556
 557 void
 558 SapiDocu_PE::AddDocuToken2SinceAtTag( DYN ary::inf::DocuToken & let_drNewToken )
 559 {
 560     csv_assert(pCurAtTag);
 561     String &
 562         sValue = pCurAtTag->Access_Text().Access_TextOfFirstToken();
 563     StreamLock
 564         sHelp(1000);
 565
 566     DT_TextToken *
 567         pToken = dynamic_cast< DT_TextToken* >(&let_drNewToken);
 568     if (pToken != 0)
 569     {
 570         sValue = sHelp() << sValue << pToken->GetText() << c_str;
 571     }
 572     else if (dynamic_cast< DT_White* >(&let_drNewToken) != 0)
 573     {
 574         sValue = sHelp() << sValue << " " << c_str;
 575     }
 576       delete &let_drNewToken;
 577 }
 578
 579 const char *
 580 AtTagTitle( const Tok_AtTag & i_rToken )
 581 {
 582     switch (i_rToken.Id())
 583     {
 584         case Tok_AtTag::author:         return "";
 585         case Tok_AtTag::see:        return "See also";
 586         case Tok_AtTag::param:      return "Parameters";
 587         case Tok_AtTag::e_return:       return "Returns";
 588         case Tok_AtTag::e_throw:        return "Throws";
 589         case Tok_AtTag::example:        return "Example";
 590         case Tok_AtTag::deprecated:     return "Deprecated";
 591         case Tok_AtTag::suspicious:     return "";
 592         case Tok_AtTag::missing:        return "";
 593         case Tok_AtTag::incomplete:     return "";
 594         case Tok_AtTag::version:        return "";
 595         case Tok_AtTag::guarantees:     return "Guarantees";
 596         case Tok_AtTag::exception:      return "Exception";
 597         case Tok_AtTag::since:      return "Since version";
 598         default:
 599             //  See below.
 600             ;
 601     }
 602     return i_rToken.Text();
 603 }
 604
 605
 606
 607 }   // namespace dsapi
 608 }   // namespace csi
 609