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