Doxygen
Loading...
Searching...
No Matches
DocPara Class Referencefinal

Node representing a paragraph in the documentation tree. More...

#include <src/docnode.h>

Inheritance diagram for DocPara:
Collaboration diagram for DocPara:

Public Member Functions

 DocPara (DocParser *parser, DocNodeVariant *parent)
Token parse ()
bool empty () const
void markFirst (bool v=true)
void markLast (bool v=true)
bool isFirst () const
bool isLast () const
Token handleCommand (char cmdChar, const DString &cmdName)
Token handleHtmlStartTag (const DString &tagName, const HtmlAttribList &tagHtmlAttribs)
Token handleHtmlEndTag (const DString &tagName)
Token handleSimpleSection (DocSimpleSect::Type t, bool xmlContext=false)
Token handleXRefItem ()
Token handleParamSection (const DString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
void handleIncludeOperator (const DString &cmdName, DocIncOperator::Type t)
template<class T>
void handleFile (const DString &cmdName)
void handleInclude (const DString &cmdName, DocInclude::Type t)
void handleLink (const DString &cmdName, bool isJavaLink)
void handleDoxyConfig (char cmdChar, const DString &cmdName)
void handleEmoji (char cmdChar, const DString &cmdName)
void handleSection (char cmdChar, const DString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void handleShowDate (char cmdChar, const DString &cmdName)
Token handleStartCode ()
Token handleHtmlHeader (const HtmlAttribList &tagHtmlAttribs, int level)
bool injectToken (Token tok, const DString &tokText)
const HtmlAttribList & attribs () const
void setAttribs (const HtmlAttribList &attribs)
Public Member Functions inherited from DocCompoundNode
 DocCompoundNode (DocParser *parser, DocNodeVariant *parent)
DocNodeList & children ()
const DocNodeList & children () const
Public Member Functions inherited from DocNode
 DocNode (DocParser *parser, DocNodeVariant *parent)
 ~DocNode ()=default
DocNodeVariant * parent ()
const DocNodeVariant * parent () const
DocNodeVariant * thisVariant ()
const DocNodeVariant * thisVariant () const
void setThisVariant (DocNodeVariant *thisVariant)
DocParser * parser ()
const DocParser * parser () const
void setParent (DocNodeVariant *parent)
bool isPreformatted () const

Private Attributes

bool m_isFirst = false
bool m_isLast = false
HtmlAttribList m_attribs

Additional Inherited Members

Protected Types inherited from DocNode
enum  RefType {
  Unknown , Anchor , Section , Table ,
  Requirement
}
Protected Member Functions inherited from DocNode
void setInsidePreformatted (bool p)

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1088 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

DocPara::DocPara ( DocParser * parser,
DocNodeVariant * parent )

Definition at line 3578 of file docnode.cpp.

3578 :
3579 DocCompoundNode(parser,parent),
3580 m_isFirst(false), m_isLast(false)
3581{
3582}
DocCompoundNode::DocCompoundNode
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:141
DocNode::parser
DocParser * parser()
Definition docnode.h:97
DocNode::parent
DocNodeVariant * parent()
Definition docnode.h:89
DocPara::m_isFirst
bool m_isFirst
Definition docnode.h:1123
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1124

References DocCompoundNode::DocCompoundNode(), m_isFirst, m_isLast, DocNode::parent(), and DocNode::parser().

Referenced by parse().

Member Function Documentation

◆ attribs()

const HtmlAttribList & DocPara::attribs ( ) const
inline

Definition at line 1119 of file docnode.h.

1119{ return m_attribs; }
DocPara::m_attribs
HtmlAttribList m_attribs
Definition docnode.h:1125

References m_attribs.

Referenced by HtmlDocVisitor::operator()(), and setAttribs().

◆ empty()

bool DocPara::empty ( ) const
inline

Definition at line 1093 of file docnode.h.

1093{ return children().empty(); }
DocCompoundNode::children
DocNodeList & children()
Definition docnode.h:143
GrowVector::empty
bool empty() const
checks whether the container is empty
Definition growvector.h:140

References DocCompoundNode::children(), and GrowVector< T >::empty().

Referenced by handleHtmlStartTag(), handleParamSection(), handleSimpleSection(), and parse().

◆ handleCommand()

Token DocPara::handleCommand ( char cmdChar,
const DString & cmdName )

Definition at line 4229 of file docnode.cpp.

4230{
4231 AUTO_TRACE("cmdName={}",cmdName);
4232 Token retval = Token::make_RetVal_OK();
4233 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
4234 switch (cmdId)
4235 {
4236 case CommandType::UNKNOWN:
4237 {
4238 std::string str{cmdChar};
4239 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
4240 if (isAliasCmd(cmdName.view()))
4241 {
4242 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
4243 }
4244 else
4245 {
4246 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4247 }
4248 }
4249 break;
4250 case CommandType::CMD_EMPHASIS:
4251 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,true);
4252 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4253 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,false);
4254 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4255 break;
4256 case CommandType::CMD_BOLD:
4257 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,true);
4258 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4259 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,false);
4260 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4261 break;
4262 case CommandType::CMD_CODE:
4263 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,true);
4264 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4265 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,false);
4266 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4267 break;
4268 case CommandType::CMD_BSLASH:
4269 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_BSlash);
4270 break;
4271 case CommandType::CMD_AT:
4272 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_At);
4273 break;
4274 case CommandType::CMD_LESS:
4275 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Less);
4276 break;
4277 case CommandType::CMD_GREATER:
4278 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Greater);
4279 break;
4280 case CommandType::CMD_AMP:
4281 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Amp);
4282 break;
4283 case CommandType::CMD_DOLLAR:
4284 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Dollar);
4285 break;
4286 case CommandType::CMD_HASH:
4287 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Hash);
4288 break;
4289 case CommandType::CMD_PIPE:
4290 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Pipe);
4291 break;
4292 case CommandType::CMD_DCOLON:
4293 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_DoubleColon);
4294 break;
4295 case CommandType::CMD_PERCENT:
4296 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Percent);
4297 break;
4298 case CommandType::CMD_NDASH:
4299 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4300 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4301 break;
4302 case CommandType::CMD_MDASH:
4303 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4304 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4305 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4306 break;
4307 case CommandType::CMD_QUOTE:
4308 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Quot);
4309 break;
4310 case CommandType::CMD_PUNT:
4311 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Dot);
4312 break;
4313 case CommandType::CMD_EXCLAMATION:
4314 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Exclam);
4315 break;
4316 case CommandType::CMD_QUESTION:
4317 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Quest);
4318 break;
4319 case CommandType::CMD_PLUS:
4320 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Plus);
4321 break;
4322 case CommandType::CMD_MINUS:
4323 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4324 break;
4325 case CommandType::CMD_EQUAL:
4326 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Equal);
4327 break;
4328 case CommandType::CMD_SA:
4329 parser()->context.inSeeBlock=true;
4330 retval = handleSimpleSection(DocSimpleSect::See);
4331 parser()->context.inSeeBlock=false;
4332 break;
4333 case CommandType::CMD_RETURN:
4334 retval = handleSimpleSection(DocSimpleSect::Return);
4335 parser()->context.hasReturnCommand=true;
4336 break;
4337 case CommandType::CMD_AUTHOR:
4338 retval = handleSimpleSection(DocSimpleSect::Author);
4339 break;
4340 case CommandType::CMD_AUTHORS:
4341 retval = handleSimpleSection(DocSimpleSect::Authors);
4342 break;
4343 case CommandType::CMD_VERSION:
4344 retval = handleSimpleSection(DocSimpleSect::Version);
4345 break;
4346 case CommandType::CMD_SINCE:
4347 retval = handleSimpleSection(DocSimpleSect::Since);
4348 break;
4349 case CommandType::CMD_DATE:
4350 retval = handleSimpleSection(DocSimpleSect::Date);
4351 break;
4352 case CommandType::CMD_NOTE:
4353 retval = handleSimpleSection(DocSimpleSect::Note);
4354 break;
4355 case CommandType::CMD_WARNING:
4356 retval = handleSimpleSection(DocSimpleSect::Warning);
4357 break;
4358 case CommandType::CMD_PRE:
4359 retval = handleSimpleSection(DocSimpleSect::Pre);
4360 break;
4361 case CommandType::CMD_POST:
4362 retval = handleSimpleSection(DocSimpleSect::Post);
4363 break;
4364 case CommandType::CMD_COPYRIGHT:
4365 retval = handleSimpleSection(DocSimpleSect::Copyright);
4366 break;
4367 case CommandType::CMD_INVARIANT:
4368 retval = handleSimpleSection(DocSimpleSect::Invar);
4369 break;
4370 case CommandType::CMD_REMARK:
4371 retval = handleSimpleSection(DocSimpleSect::Remark);
4372 break;
4373 case CommandType::CMD_ATTENTION:
4374 retval = handleSimpleSection(DocSimpleSect::Attention);
4375 break;
4376 case CommandType::CMD_IMPORTANT:
4377 retval = handleSimpleSection(DocSimpleSect::Important);
4378 break;
4379 case CommandType::CMD_PAR:
4380 retval = handleSimpleSection(DocSimpleSect::User);
4381 break;
4382 case CommandType::CMD_LI:
4383 {
4384 children().append<DocSimpleList>(parser(),thisVariant());
4385 retval = children().get_last<DocSimpleList>()->parse();
4386 }
4387 break;
4388 case CommandType::CMD_SECTION:
4389 {
4390 handleSection(cmdChar,cmdName);
4391 retval = Token::make_RetVal_Section();
4392 }
4393 break;
4394 case CommandType::CMD_SUBSECTION:
4395 {
4396 handleSection(cmdChar,cmdName);
4397 retval = Token::make_RetVal_Subsection();
4398 }
4399 break;
4400 case CommandType::CMD_SUBSUBSECTION:
4401 {
4402 handleSection(cmdChar,cmdName);
4403 retval = Token::make_RetVal_Subsubsection();
4404 }
4405 break;
4406 case CommandType::CMD_PARAGRAPH:
4407 {
4408 handleSection(cmdChar,cmdName);
4409 retval = Token::make_RetVal_Paragraph();
4410 }
4411 break;
4412 case CommandType::CMD_SUBPARAGRAPH:
4413 {
4414 handleSection(cmdChar,cmdName);
4415 retval = Token::make_RetVal_SubParagraph();
4416 }
4417 break;
4418 case CommandType::CMD_SUBSUBPARAGRAPH:
4419 {
4420 handleSection(cmdChar,cmdName);
4421 retval = Token::make_RetVal_SubSubParagraph();
4422 }
4423 break;
4424 case CommandType::CMD_ISTARTCODE:
4425 {
4426 parser()->tokenizer.setStateICode();
4427 retval = handleStartCode();
4428 }
4429 break;
4430 case CommandType::CMD_STARTCODE:
4431 {
4432 parser()->tokenizer.setStateCode();
4433 retval = handleStartCode();
4434 }
4435 break;
4436 case CommandType::CMD_HTMLONLY:
4437 {
4438 parser()->tokenizer.setStateHtmlOnly();
4439 retval = parser()->tokenizer.lex();
4440 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::HtmlOnly,parser()->context.isExample,parser()->context.exampleName,parser()->context.token->name=="block");
4441 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4442 {
4443 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4444 }
4445 parser()->tokenizer.setStatePara();
4446 }
4447 break;
4448 case CommandType::CMD_MANONLY:
4449 {
4450 parser()->tokenizer.setStateManOnly();
4451 retval = parser()->tokenizer.lex();
4452 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::ManOnly,parser()->context.isExample,parser()->context.exampleName);
4453 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4454 {
4455 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4456 }
4457 parser()->tokenizer.setStatePara();
4458 }
4459 break;
4460 case CommandType::CMD_RTFONLY:
4461 {
4462 parser()->tokenizer.setStateRtfOnly();
4463 retval = parser()->tokenizer.lex();
4464 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::RtfOnly,parser()->context.isExample,parser()->context.exampleName);
4465 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4466 {
4467 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4468 }
4469 parser()->tokenizer.setStatePara();
4470 }
4471 break;
4472 case CommandType::CMD_LATEXONLY:
4473 {
4474 parser()->tokenizer.setStateLatexOnly();
4475 retval = parser()->tokenizer.lex();
4476 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::LatexOnly,parser()->context.isExample,parser()->context.exampleName);
4477 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4478 {
4479 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4480 }
4481 parser()->tokenizer.setStatePara();
4482 }
4483 break;
4484 case CommandType::CMD_XMLONLY:
4485 {
4486 parser()->tokenizer.setStateXmlOnly();
4487 retval = parser()->tokenizer.lex();
4488 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::XmlOnly,parser()->context.isExample,parser()->context.exampleName);
4489 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4490 {
4491 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4492 }
4493 parser()->tokenizer.setStatePara();
4494 }
4495 break;
4496 case CommandType::CMD_DBONLY:
4497 {
4498 parser()->tokenizer.setStateDbOnly();
4499 retval = parser()->tokenizer.lex();
4500 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::DocbookOnly,parser()->context.isExample,parser()->context.exampleName);
4501 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4502 {
4503 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4504 }
4505 parser()->tokenizer.setStatePara();
4506 }
4507 break;
4508 case CommandType::CMD_ILITERAL:
4509 {
4510 DocVerbatim::Type t = DocVerbatim::JavaDocLiteral;
4511 parser()->tokenizer.setStateILiteralOpt();
4512 parser()->tokenizer.lex();
4513
4514 DString fullMatch = parser()->context.token->verb;
4515 size_t idx = fullMatch.find('{');
4516 size_t idxEnd = idx!=DString::npos ? fullMatch.find("}",idx+1) : DString::npos;
4517 StringVector optList;
4518 if (idx!=DString::npos && idxEnd!=DString::npos) // options present
4519 {
4520 DString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4521 optList = split(optStr.str(),",");
4522 for (const auto &opt : optList)
4523 {
4524 if (opt.empty()) continue;
4525 DString locOpt(opt);
4526 locOpt = locOpt.stripWhiteSpace().lower();
4527 if (locOpt == "code")
4528 {
4529 t = DocVerbatim::JavaDocCode;
4530 }
4531 else if (!locOpt.empty())
4532 {
4533 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4534 }
4535 }
4536 }
4537
4538 parser()->tokenizer.setStateILiteral();
4539 retval = parser()->tokenizer.lex();
4540 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,t,parser()->context.isExample,parser()->context.exampleName);
4541 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4542 {
4543 if (t == DocVerbatim::JavaDocCode)
4544 {
4545 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4546 }
4547 else
4548 {
4549 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4550 }
4551 }
4552 parser()->tokenizer.setStatePara();
4553 }
4554 break;
4555 case CommandType::CMD_IVERBATIM:
4556 case CommandType::CMD_VERBATIM:
4557 {
4558 if (cmdId == CommandType::CMD_VERBATIM)
4559 {
4560 parser()->tokenizer.setStateVerbatim();
4561 }
4562 else
4563 {
4564 parser()->tokenizer.setStateIVerbatim();
4565 }
4566 retval = parser()->tokenizer.lex();
4567 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::Verbatim,parser()->context.isExample,parser()->context.exampleName);
4568 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4569 {
4570 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4571 }
4572 parser()->tokenizer.setStatePara();
4573 }
4574 break;
4575 case CommandType::CMD_DOT:
4576 {
4577 children().append<DocVerbatim>(parser(),thisVariant(),
4578 parser()->context.context,
4579 parser()->context.token->verb,
4580 DocVerbatim::Dot,
4581 parser()->context.isExample,
4582 parser()->context.exampleName);
4583 DocVerbatim *dv = children().get_last<DocVerbatim>();
4584 parser()->tokenizer.setStatePara();
4585 DString width,height;
4586 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4587 parser()->tokenizer.setStateDot();
4588 retval = parser()->tokenizer.lex();
4589 dv->setText(parser()->context.token->verb);
4590 dv->setWidth(width);
4591 dv->setHeight(height);
4592 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4593 if (!Config_getBool(HAVE_DOT))
4594 {
4595 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4596 children().pop_back();
4597 }
4598 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4599 {
4600 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4601 }
4602 parser()->tokenizer.setStatePara();
4603 }
4604 break;
4605 case CommandType::CMD_MSC:
4606 {
4607 children().append<DocVerbatim>(parser(),thisVariant(),
4608 parser()->context.context,
4609 parser()->context.token->verb,
4610 DocVerbatim::Msc,
4611 parser()->context.isExample,
4612 parser()->context.exampleName);
4613 DocVerbatim *dv = children().get_last<DocVerbatim>();
4614 parser()->tokenizer.setStatePara();
4615 DString width,height;
4616 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4617 parser()->tokenizer.setStateMsc();
4618 retval = parser()->tokenizer.lex();
4619 dv->setText(parser()->context.token->verb);
4620 dv->setWidth(width);
4621 dv->setHeight(height);
4622 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4623 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4624 {
4625 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4626 }
4627 parser()->tokenizer.setStatePara();
4628 }
4629 break;
4630 case CommandType::CMD_STARTUML:
4631 {
4632 bool plantumlEnabled = PlantumlManager::isEnabled();
4633 parser()->tokenizer.setStatePlantUMLOpt();
4634 parser()->tokenizer.lex();
4635 DString fullMatch = parser()->context.token->sectionId;
4636 DString sectionId = "";
4637 size_t idx = fullMatch.find('{');
4638 size_t idxEnd = idx!=DString::npos ? fullMatch.find("}",idx+1) : DString::npos;
4639 StringVector optList;
4640 DString engine;
4641 if (idx!=DString::npos && idxEnd!=DString::npos) // options present
4642 {
4643 DString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4644 optList = split(optStr.str(),",");
4645 for (const auto &opt : optList)
4646 {
4647 if (opt.empty()) continue;
4648 bool found = false;
4649 DString locOpt(opt);
4650 locOpt = locOpt.stripWhiteSpace().lower();
4651 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4652 {
4653 if (!engine.empty())
4654 {
4655 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4656 }
4657 engine = locOpt;
4658 found = true;
4659 }
4660 if (!found)
4661 {
4662 if (sectionId.empty())
4663 {
4664 sectionId = opt;
4665 }
4666 else
4667 {
4668 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4669 }
4670 }
4671 }
4672 }
4673 else
4674 {
4675 sectionId = parser()->context.token->sectionId;
4676 }
4677 if (engine.empty()) engine = "uml";
4678
4679 if (sectionId.empty())
4680 {
4681 parser()->tokenizer.setStatePlantUMLOpt();
4682 retval = parser()->tokenizer.lex();
4683 ASSERT(retval.is(TokenRetval::RetVal_OK));
4684
4685 sectionId = parser()->context.token->sectionId;
4686 sectionId = sectionId.stripWhiteSpace();
4687 }
4688
4689 DString plantFile(sectionId);
4690 children().append<DocVerbatim>(parser(),thisVariant(),
4691 parser()->context.context,
4692 parser()->context.token->verb,
4693 DocVerbatim::PlantUML,
4694 false,plantFile);
4695 DocVerbatim *dv = children().get_last<DocVerbatim>();
4696 dv->setEngine(engine);
4697 parser()->tokenizer.setStatePara();
4698 DString width,height;
4699 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4700 parser()->tokenizer.setStatePlantUML();
4701 retval = parser()->tokenizer.lex();
4702 int line = 0;
4703 DString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4704 if (engine == "ditaa")
4705 {
4706 dv->setUseBitmap(true);
4707 }
4708 else if (engine == "uml")
4709 {
4710 size_t i = trimmedVerb.find('\n');
4711 DString firstLine = i==DString::npos ? trimmedVerb : trimmedVerb.left(i);
4712 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4713 }
4714 dv->setText(trimmedVerb);
4715 dv->setWidth(width);
4716 dv->setHeight(height);
4717 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4718 if (!plantumlEnabled)
4719 {
4720 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because neither PLANTUML_JAR_PATH nor PLANTUML_TOOL is set");
4721 children().pop_back();
4722 }
4723 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4724 {
4725 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4726 }
4727 parser()->tokenizer.setStatePara();
4728 }
4729 break;
4730 case CommandType::CMD_MERMAID:
4731 {
4732 parser()->tokenizer.setStateMermaidOpt();
4733 parser()->tokenizer.lex();
4734 DString fullMatch = parser()->context.token->sectionId;
4735 DString sectionId = "";
4736 size_t idx = fullMatch.find('{');
4737 size_t idxEnd = idx!=DString::npos ? fullMatch.find("}",idx+1) : DString::npos;
4738 if (idx!=DString::npos && idxEnd!=DString::npos) // options present
4739 {
4740 sectionId = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4741 }
4742 else
4743 {
4744 sectionId = parser()->context.token->sectionId;
4745 }
4746
4747 if (sectionId.empty())
4748 {
4749 parser()->tokenizer.setStateMermaidOpt();
4750 retval = parser()->tokenizer.lex();
4751 ASSERT(retval.is(TokenRetval::RetVal_OK));
4752
4753 sectionId = parser()->context.token->sectionId;
4754 sectionId = sectionId.stripWhiteSpace();
4755 }
4756
4757 DString mermaidFile(sectionId);
4758 children().append<DocVerbatim>(parser(),thisVariant(),
4759 parser()->context.context,
4760 parser()->context.token->verb,
4761 DocVerbatim::Mermaid,
4762 false,mermaidFile);
4763 DocVerbatim *dv = children().get_last<DocVerbatim>();
4764 parser()->tokenizer.setStatePara();
4765 DString width,height;
4766 parser()->defaultHandleTitleAndSize(CommandType::CMD_MERMAID,&children().back(),dv->children(),width,height);
4767 parser()->tokenizer.setStateMermaid();
4768 retval = parser()->tokenizer.lex();
4769 int line = 0;
4770 DString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4771 dv->setText(trimmedVerb);
4772 dv->setWidth(width);
4773 dv->setHeight(height);
4774 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4775 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4776 {
4777 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"mermaid section ended without end marker");
4778 }
4779 parser()->tokenizer.setStatePara();
4780 }
4781 break;
4782 case CommandType::CMD_ENDPARBLOCK:
4783 retval = Token::make_RetVal_EndParBlock();
4784 break;
4785 case CommandType::CMD_ENDICODE:
4786 case CommandType::CMD_ENDCODE:
4787 case CommandType::CMD_ENDHTMLONLY:
4788 case CommandType::CMD_ENDMANONLY:
4789 case CommandType::CMD_ENDRTFONLY:
4790 case CommandType::CMD_ENDLATEXONLY:
4791 case CommandType::CMD_ENDXMLONLY:
4792 case CommandType::CMD_ENDDBONLY:
4793 case CommandType::CMD_ENDLINK:
4794 case CommandType::CMD_ENDVERBATIM:
4795 case CommandType::CMD_ENDIVERBATIM:
4796 case CommandType::CMD_ENDILITERAL:
4797 case CommandType::CMD_ENDDOT:
4798 case CommandType::CMD_ENDMSC:
4799 case CommandType::CMD_ENDUML:
4800 case CommandType::CMD_ENDMERMAID:
4801 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4802 break;
4803 case CommandType::CMD_PARAM:
4804 retval = handleParamSection(cmdName,DocParamSect::Param,false,parser()->context.token->paramDir);
4805 parser()->context.paramPosition++;
4806 break;
4807 case CommandType::CMD_TPARAM:
4808 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,false,parser()->context.token->paramDir);
4809 break;
4810 case CommandType::CMD_RETVAL:
4811 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4812 break;
4813 case CommandType::CMD_EXCEPTION:
4814 retval = handleParamSection(cmdName,DocParamSect::Exception);
4815 break;
4816 case CommandType::CMD_XREFITEM:
4817 retval = handleXRefItem();
4818 break;
4819 case CommandType::CMD_LINEBREAK:
4820 {
4821 children().append<DocLineBreak>(parser(),thisVariant());
4822 }
4823 break;
4824 case CommandType::CMD_IANCHOR:
4825 case CommandType::CMD_ANCHOR:
4826 {
4827 parser()->handleAnchor(thisVariant(),children());
4828 }
4829 break;
4830 case CommandType::CMD_IPREFIX:
4831 {
4832 parser()->handlePrefix(thisVariant(),children());
4833 }
4834 break;
4835 case CommandType::CMD_ADDINDEX:
4836 {
4837 children().append<DocIndexEntry>(parser(),thisVariant(),
4838 parser()->context.scope!=Doxygen::globalScope?parser()->context.scope:nullptr,
4839 parser()->context.memberDef);
4840 retval = children().get_last<DocIndexEntry>()->parse();
4841 }
4842 break;
4843 case CommandType::CMD_INTERNAL:
4844 retval = Token::make_RetVal_Internal();
4845 break;
4846 case CommandType::CMD_ENDINTERNAL:
4847 retval = Token::make_RetVal_EndInternal();
4848 break;
4849 case CommandType::CMD_PARBLOCK:
4850 {
4851 children().append<DocParBlock>(parser(),thisVariant());
4852 retval = children().get_last<DocParBlock>()->parse();
4853 }
4854 break;
4855 case CommandType::CMD_COPYDOC: // fall through
4856 case CommandType::CMD_COPYBRIEF: // fall through
4857 case CommandType::CMD_COPYDETAILS:
4858 //retval = Token::make_RetVal_CopyDoc();
4859 // these commands should already be resolved by processCopyDoc()
4860 break;
4861 case CommandType::CMD_INCLUDE:
4862 handleInclude(cmdName,DocInclude::Include);
4863 break;
4864 case CommandType::CMD_INCWITHLINES:
4865 handleInclude(cmdName,DocInclude::IncWithLines);
4866 break;
4867 case CommandType::CMD_DONTINCLUDE:
4868 handleInclude(cmdName,DocInclude::DontInclude);
4869 break;
4870 case CommandType::CMD_HTMLINCLUDE:
4871 handleInclude(cmdName,DocInclude::HtmlInclude);
4872 break;
4873 case CommandType::CMD_LATEXINCLUDE:
4874 handleInclude(cmdName,DocInclude::LatexInclude);
4875 break;
4876 case CommandType::CMD_RTFINCLUDE:
4877 handleInclude(cmdName,DocInclude::RtfInclude);
4878 break;
4879 case CommandType::CMD_MANINCLUDE:
4880 handleInclude(cmdName,DocInclude::ManInclude);
4881 break;
4882 case CommandType::CMD_XMLINCLUDE:
4883 handleInclude(cmdName,DocInclude::XmlInclude);
4884 break;
4885 case CommandType::CMD_DOCBOOKINCLUDE:
4886 handleInclude(cmdName,DocInclude::DocbookInclude);
4887 break;
4888 case CommandType::CMD_VERBINCLUDE:
4889 handleInclude(cmdName,DocInclude::VerbInclude);
4890 break;
4891 case CommandType::CMD_SNIPPET:
4892 handleInclude(cmdName,DocInclude::Snippet);
4893 break;
4894 case CommandType::CMD_SNIPWITHLINES:
4895 handleInclude(cmdName,DocInclude::SnippetWithLines);
4896 break;
4897 case CommandType::CMD_SKIP:
4898 handleIncludeOperator(cmdName,DocIncOperator::Skip);
4899 break;
4900 case CommandType::CMD_UNTIL:
4901 handleIncludeOperator(cmdName,DocIncOperator::Until);
4902 break;
4903 case CommandType::CMD_SKIPLINE:
4904 handleIncludeOperator(cmdName,DocIncOperator::SkipLine);
4905 break;
4906 case CommandType::CMD_LINE:
4907 handleIncludeOperator(cmdName,DocIncOperator::Line);
4908 break;
4909 case CommandType::CMD_IMAGE:
4910 parser()->handleImage(thisVariant(),children());
4911 break;
4912 case CommandType::CMD_DOTFILE:
4913 if (!Config_getBool(HAVE_DOT))
4914 {
4915 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4916 "ignoring \\dotfile command because HAVE_DOT is not set");
4917 }
4918 else
4919 {
4920 handleFile<DocDotFile>(cmdName);
4921 }
4922 break;
4923 case CommandType::CMD_VHDLFLOW:
4924 handleVhdlFlow();
4925 break;
4926 case CommandType::CMD_MSCFILE:
4927 handleFile<DocMscFile>(cmdName);
4928 break;
4929 case CommandType::CMD_DIAFILE:
4930 handleFile<DocDiaFile>(cmdName);
4931 break;
4932 case CommandType::CMD_PLANTUMLFILE:
4933 handleFile<DocPlantUmlFile>(cmdName);
4934 break;
4935 case CommandType::CMD_MERMAIDFILE:
4936 handleFile<DocMermaidFile>(cmdName);
4937 break;
4938 case CommandType::CMD_LINK:
4939 handleLink(cmdName,false);
4940 break;
4941 case CommandType::CMD_JAVALINK:
4942 handleLink(cmdName,true);
4943 break;
4944 case CommandType::CMD_CITE:
4945 {
4946 parser()->handleCite(thisVariant(),children());
4947 }
4948 break;
4949 case CommandType::CMD_EMOJI:
4950 handleEmoji(cmdChar,cmdName);
4951 break;
4952 case CommandType::CMD_DOXYCONFIG:
4953 handleDoxyConfig(cmdChar,cmdName);
4954 break;
4955 case CommandType::CMD_REF:
4956 // fall through
4957 case CommandType::CMD_SUBPAGE:
4958 parser()->handleRef(thisVariant(),children(),cmdChar,cmdName);
4959 break;
4960 case CommandType::CMD_SECREFLIST:
4961 {
4962 children().append<DocSecRefList>(parser(),thisVariant());
4963 children().get_last<DocSecRefList>()->parse();
4964 }
4965 break;
4966 case CommandType::CMD_SECREFITEM:
4967 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4968 break;
4969 case CommandType::CMD_ENDSECREFLIST:
4970 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4971 break;
4972 case CommandType::CMD_FORMULA:
4973 {
4974 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4975 }
4976 break;
4977 //case CommandType::CMD_LANGSWITCH:
4978 // retval = handleLanguageSwitch();
4979 // break;
4980 case CommandType::CMD_INTERNALREF:
4981 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4982 {
4983 parser()->handleInternalRef(thisVariant(),children());
4984 parser()->tokenizer.setStatePara();
4985 }
4986 break;
4987 case CommandType::CMD_INHERITDOC:
4988 handleInheritDoc();
4989 break;
4990 case CommandType::CMD_SHOWDATE:
4991 handleShowDate(cmdChar,cmdName);
4992 break;
4993 case CommandType::CMD_ILINE:
4994 parser()->handleILine(cmdChar,cmdName);
4995 break;
4996 case CommandType::CMD_IFILE:
4997 parser()->handleIFile(cmdChar,cmdName);
4998 break;
4999 case CommandType::CMD_SETSCOPE:
5000 {
5001 parser()->tokenizer.setStateSetScope();
5002 (void)parser()->tokenizer.lex();
5003 parser()->context.context = parser()->context.token->name;
5004 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
5005 parser()->tokenizer.setStatePara();
5006 }
5007 break;
5008 default:
5009 // we should not get here!
5010 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
5011 break;
5012 }
5013 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
5014 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
5015 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
5016 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
5017 TokenRetval::RetVal_EndInternal)
5018 );
5019 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5020 return retval;
5021}
isAliasCmd
bool isAliasCmd(std::string_view aliasCmd)
Definition aliases.cpp:519
DString::mid
DString mid(size_t index, size_t len=npos) const
Definition dstring.h:318
DString::empty
bool empty() const
Returns true iff the string is empty (std::string compatible alias for isEmpty()).
Definition dstring.h:148
DString::view
std::string_view view() const
Definition dstring.h:162
DString::npos
static constexpr size_t npos
value used to indicate 'not found' or 'to the end of the string', matching std::string::npos
Definition dstring.h:178
DString::find
size_t find(char c, size_t pos=0) const
Definition dstring.h:239
DString::stripWhiteSpace
DString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition dstring.h:337
DString::left
DString left(size_t len) const
Definition dstring.h:306
DString::str
const std::string & str() const
Definition dstring.h:645
DocInclude::LatexInclude
@ LatexInclude
Definition docnode.h:437
DocInclude::SnippetWithLines
@ SnippetWithLines
Definition docnode.h:438
DocInclude::IncWithLines
@ IncWithLines
Definition docnode.h:438
DocInclude::HtmlInclude
@ HtmlInclude
Definition docnode.h:437
DocInclude::VerbInclude
@ VerbInclude
Definition docnode.h:437
DocInclude::DontInclude
@ DontInclude
Definition docnode.h:437
DocInclude::DocbookInclude
@ DocbookInclude
Definition docnode.h:439
DocNode::thisVariant
DocNodeVariant * thisVariant()
Definition docnode.h:92
DocNodeList::append
void append(Args &&... args)
Append a new DocNodeVariant to the list by constructing it with type T and parameters Args.
Definition docnode.h:1404
DocNodeList::get_last
T * get_last()
Returns a pointer to the last element in the list if that element exists and holds a T,...
Definition docnode.h:1415
DocPara::handleFile
void handleFile(const DString &cmdName)
Definition docnode.cpp:3918
DocPara::handleInheritDoc
void handleInheritDoc()
Definition docnode.cpp:4188
DocPara::handleShowDate
void handleShowDate(char cmdChar, const DString &cmdName)
Definition docnode.cpp:3788
DocPara::handleIncludeOperator
void handleIncludeOperator(const DString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3858
DocPara::handleLink
void handleLink(const DString &cmdName, bool isJavaLink)
Definition docnode.cpp:3957
DocPara::handleInclude
void handleInclude(const DString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3998
DocPara::handleSimpleSection
Token handleSimpleSection(DocSimpleSect::Type t, bool xmlContext=false)
Definition docnode.cpp:3584
DocPara::handleEmoji
void handleEmoji(char cmdChar, const DString &cmdName)
Definition docnode.cpp:3637
DocPara::handleParamSection
Token handleParamSection(const DString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3614
DocPara::handleSection
void handleSection(char cmdChar, const DString &cmdName)
Definition docnode.cpp:4103
DocPara::parse
Token parse()
Definition docnode.cpp:5782
DocPara::handleVhdlFlow
void handleVhdlFlow()
Definition docnode.cpp:3950
DocPara::handleDoxyConfig
void handleDoxyConfig(char cmdChar, const DString &cmdName)
Definition docnode.cpp:3668
DocPara::handleXRefItem
Token handleXRefItem()
Definition docnode.cpp:3766
DocPara::handleStartCode
Token handleStartCode()
Definition docnode.cpp:4152
DocParser::handleIFile
void handleIFile(char cmdChar, const DString &cmdName)
Definition docparser.cpp:1447
DocParser::tokenizer
DocTokenizer tokenizer
Definition docparser_p.h:153
DocParser::handleInternalRef
void handleInternalRef(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1039
DocParser::handleRef
void handleRef(DocNodeVariant *parent, DocNodeList &children, char cmdChar, const DString &cmdName)
Definition docparser.cpp:1421
DocParser::handleStyleArgument
Token handleStyleArgument(DocNodeVariant *parent, DocNodeList &children, const DString &cmdName)
Definition docparser.cpp:646
DocParser::defaultHandleTitleAndSize
void defaultHandleTitleAndSize(const CommandType cmd, DocNodeVariant *parent, DocNodeList &children, DString &width, DString &height)
Definition docparser.cpp:1231
DocParser::handleImage
void handleImage(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1315
DocParser::handleCite
void handleCite(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1091
DocParser::handlePrefix
void handlePrefix(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1195
DocParser::handleILine
void handleILine(char cmdChar, const DString &cmdName)
Definition docparser.cpp:1469
DocParser::context
DocParserContext context
Definition docparser_p.h:152
DocParser::handleAnchor
void handleAnchor(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1061
DocTokenizer::setStateILiteralOpt
void setStateILiteralOpt()
Definition doctokenizer.l:2005
DocTokenizer::setStateILiteral
void setStateILiteral()
Definition doctokenizer.l:1997
DocTokenizer::setStateMermaidOpt
void setStateMermaidOpt()
Definition doctokenizer.l:2062
DocTokenizer::setStateCode
void setStateCode()
Definition doctokenizer.l:1921
DocTokenizer::setStatePlantUMLOpt
void setStatePlantUMLOpt()
Definition doctokenizer.l:2045
DocTokenizer::setStateRtfOnly
void setStateRtfOnly()
Definition doctokenizer.l:1965
DocTokenizer::setStateVerbatim
void setStateVerbatim()
Definition doctokenizer.l:2013
DocTokenizer::setStateLatexOnly
void setStateLatexOnly()
Definition doctokenizer.l:1989
DocTokenizer::setStateManOnly
void setStateManOnly()
Definition doctokenizer.l:1957
DocTokenizer::setStateDbOnly
void setStateDbOnly()
Definition doctokenizer.l:1981
DocTokenizer::setStateHtmlOnly
void setStateHtmlOnly()
Definition doctokenizer.l:1948
DocTokenizer::setStateICode
void setStateICode()
Definition doctokenizer.l:1930
DocTokenizer::setStatePara
void setStatePara()
Definition doctokenizer.l:1899
DocTokenizer::setStatePlantUML
void setStatePlantUML()
Definition doctokenizer.l:2054
DocTokenizer::setStateIVerbatim
void setStateIVerbatim()
Definition doctokenizer.l:2021
DocTokenizer::setStateXmlOnly
void setStateXmlOnly()
Definition doctokenizer.l:1973
DocTokenizer::setStateMermaid
void setStateMermaid()
Definition doctokenizer.l:2071
DocTokenizer::setStateSetScope
void setStateSetScope()
Definition doctokenizer.l:2187
DocVerbatim::JavaDocLiteral
@ JavaDocLiteral
Definition docnode.h:378
Doxygen::globalScope
static NamespaceDefMutable * globalScope
Definition doxygen.h:114
GrowVector::pop_back
void pop_back()
removes the last element
Definition growvector.h:115
PlantumlManager::isEnabled
static bool isEnabled()
Returns true if doxygen has been configured to run PlantUML, i.e.
Definition plantuml.cpp:246
TokenInfo::verb
DString verb
Definition doctokenizer.h:156
TokenInfo::sectionId
DString sectionId
Definition doctokenizer.h:149
TokenInfo::name
DString name
Definition doctokenizer.h:136
CommandType
CommandType
Definition cmdmapper.h:30
CommandType::CMD_ENDSECREFLIST
@ CMD_ENDSECREFLIST
Definition cmdmapper.h:54
CommandType::CMD_ENDLATEXONLY
@ CMD_ENDLATEXONLY
Definition cmdmapper.h:52
CommandType::CMD_ENDVERBATIM
@ CMD_ENDVERBATIM
Definition cmdmapper.h:55
CommandType::CMD_DONTINCLUDE
@ CMD_DONTINCLUDE
Definition cmdmapper.h:47
CommandType::CMD_SUBSUBSECTION
@ CMD_SUBSUBSECTION
Definition cmdmapper.h:90
CommandType::CMD_SUBSUBPARAGRAPH
@ CMD_SUBSUBPARAGRAPH
Definition cmdmapper.h:162
CommandType::CMD_INTERNALREF
@ CMD_INTERNALREF
Definition cmdmapper.h:66
CommandType::CMD_ENDHTMLONLY
@ CMD_ENDHTMLONLY
Definition cmdmapper.h:51
CommandType::CMD_VERBINCLUDE
@ CMD_VERBINCLUDE
Definition cmdmapper.h:99
CommandType::CMD_DOCBOOKINCLUDE
@ CMD_DOCBOOKINCLUDE
Definition cmdmapper.h:146
CommandType::CMD_HTMLINCLUDE
@ CMD_HTMLINCLUDE
Definition cmdmapper.h:61
CommandType::CMD_SNIPWITHLINES
@ CMD_SNIPWITHLINES
Definition cmdmapper.h:142
Config_getBool
#define Config_getBool(name)
Definition config.h:33
StringVector
std::vector< std::string > StringVector
Definition containers.h:33
AUTO_TRACE
#define AUTO_TRACE(...)
Definition docnode.cpp:53
g_plantumlEngine
static const StringUnorderedSet g_plantumlEngine
Definition docnode.cpp:76
INTERNAL_ASSERT
#define INTERNAL_ASSERT(x)
Definition docnode.cpp:58
AUTO_TRACE_EXIT
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:55
warn
#define warn(file, line, fmt,...)
Definition message.h:97
ASSERT
#define ASSERT(x)
Definition message.h:142
warn_doc_error
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
Mappers::cmdMapper
const Mapper< CommandType > * cmdMapper
Definition cmdmapper.cpp:254
split
StringVector split(const std::string &s, const std::string &delimiter, bool retainEmpty=false)
split input string s by string delimiter delimiter.
Definition stringutil.h:119
DocParserContext::nodeStack
DocNodeStack nodeStack
Definition docparser_p.h:66
DocParserContext::scope
const Definition * scope
Definition docparser_p.h:60
DocParserContext::token
TokenInfo * token
Definition docparser_p.h:94
DocParserContext::memberDef
const MemberDef * memberDef
Definition docparser_p.h:79
DocParserContext::exampleName
DString exampleName
Definition docparser_p.h:81
stripLeadingAndTrailingEmptyLines
DString stripLeadingAndTrailingEmptyLines(const DString &s, int &docLine)
Special version of DString::stripWhiteSpace() that only strips completely blank lines.
Definition util.cpp:3993

References DocNodeList::append(), ASSERT, DocSimpleSect::Attention, DocSimpleSect::Author, DocSimpleSect::Authors, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocCompoundNode::children(), CMD_ADDINDEX, CMD_AMP, CMD_ANCHOR, CMD_AT, CMD_ATTENTION, CMD_AUTHOR, CMD_AUTHORS, CMD_BOLD, CMD_BSLASH, CMD_CITE, CMD_CODE, CMD_COPYBRIEF, CMD_COPYDETAILS, CMD_COPYDOC, CMD_COPYRIGHT, CMD_DATE, CMD_DBONLY, CMD_DCOLON, CMD_DIAFILE, CMD_DOCBOOKINCLUDE, CMD_DOLLAR, CMD_DONTINCLUDE, CMD_DOT, CMD_DOTFILE, CMD_DOXYCONFIG, CMD_EMOJI, CMD_EMPHASIS, CMD_ENDCODE, CMD_ENDDBONLY, CMD_ENDDOT, CMD_ENDHTMLONLY, CMD_ENDICODE, CMD_ENDILITERAL, CMD_ENDINTERNAL, CMD_ENDIVERBATIM, CMD_ENDLATEXONLY, CMD_ENDLINK, CMD_ENDMANONLY, CMD_ENDMERMAID, CMD_ENDMSC, CMD_ENDPARBLOCK, CMD_ENDRTFONLY, CMD_ENDSECREFLIST, CMD_ENDUML, CMD_ENDVERBATIM, CMD_ENDXMLONLY, CMD_EQUAL, CMD_EXCEPTION, CMD_EXCLAMATION, CMD_FORMULA, CMD_GREATER, CMD_HASH, CMD_HTMLINCLUDE, CMD_HTMLONLY, CMD_IANCHOR, CMD_IFILE, CMD_ILINE, CMD_ILITERAL, CMD_IMAGE, CMD_IMPORTANT, CMD_INCLUDE, CMD_INCWITHLINES, CMD_INHERITDOC, CMD_INTERNAL, CMD_INTERNALREF, CMD_INVARIANT, CMD_IPREFIX, CMD_ISTARTCODE, CMD_IVERBATIM, CMD_JAVALINK, CMD_LATEXINCLUDE, CMD_LATEXONLY, CMD_LESS, CMD_LI, CMD_LINE, CMD_LINEBREAK, CMD_LINK, CMD_MANINCLUDE, CMD_MANONLY, CMD_MDASH, CMD_MERMAID, CMD_MERMAIDFILE, CMD_MINUS, CMD_MSC, CMD_MSCFILE, CMD_NDASH, CMD_NOTE, CMD_PAR, CMD_PARAGRAPH, CMD_PARAM, CMD_PARBLOCK, CMD_PERCENT, CMD_PIPE, CMD_PLANTUMLFILE, CMD_PLUS, CMD_POST, CMD_PRE, CMD_PUNT, CMD_QUESTION, CMD_QUOTE, CMD_REF, CMD_REMARK, CMD_RETURN, CMD_RETVAL, CMD_RTFINCLUDE, CMD_RTFONLY, CMD_SA, CMD_SECREFITEM, CMD_SECREFLIST, CMD_SECTION, CMD_SETSCOPE, CMD_SHOWDATE, CMD_SINCE, CMD_SKIP, CMD_SKIPLINE, CMD_SNIPPET, CMD_SNIPWITHLINES, CMD_STARTCODE, CMD_STARTUML, CMD_SUBPAGE, CMD_SUBPARAGRAPH, CMD_SUBSECTION, CMD_SUBSUBPARAGRAPH, CMD_SUBSUBSECTION, CMD_TPARAM, CMD_UNTIL, CMD_VERBATIM, CMD_VERBINCLUDE, CMD_VERSION, CMD_VHDLFLOW, CMD_WARNING, CMD_XMLINCLUDE, CMD_XMLONLY, CMD_XREFITEM, Mappers::cmdMapper, DocStyleChange::Code, Config_getBool, DocParser::context, DocParserContext::context, DocSimpleSect::Copyright, DocSimpleSect::Date, DocParser::defaultHandleTitleAndSize(), DocInclude::DocbookInclude, DocVerbatim::DocbookOnly, DocInclude::DontInclude, DocVerbatim::Dot, DString::empty(), DocParserContext::exampleName, DocParamSect::Exception, DString::find(), g_plantumlEngine, DocNodeList::get_last(), Doxygen::globalScope, DocParser::handleAnchor(), DocParser::handleCite(), handleDoxyConfig(), handleEmoji(), handleFile(), DocParser::handleIFile(), DocParser::handleILine(), DocParser::handleImage(), handleInclude(), handleIncludeOperator(), handleInheritDoc(), DocParser::handleInternalRef(), handleLink(), handleParamSection(), DocParser::handlePrefix(), DocParser::handleRef(), handleSection(), handleShowDate(), handleSimpleSection(), handleStartCode(), DocParser::handleStyleArgument(), handleVhdlFlow(), handleXRefItem(), DocParserContext::hasReturnCommand, DocInclude::HtmlInclude, DocVerbatim::HtmlOnly, TokenInfo::id, DocSimpleSect::Important, DocInclude::Include, DocInclude::IncWithLines, DocParserContext::inSeeBlock, INTERNAL_ASSERT, DocSimpleSect::Invar, Token::is_any_of(), isAliasCmd(), PlantumlManager::isEnabled(), DocParserContext::isExample, DocStyleChange::Italic, DocVerbatim::JavaDocCode, DocVerbatim::JavaDocLiteral, DocInclude::LatexInclude, DocVerbatim::LatexOnly, DString::left(), DocTokenizer::lex(), DocIncOperator::Line, DString::lower(), DocInclude::ManInclude, DocVerbatim::ManOnly, DocParserContext::memberDef, DocVerbatim::Mermaid, DString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DString::npos, DocParamSect::Param, DocParserContext::paramPosition, parse(), DocNode::parser(), DocVerbatim::PlantUML, GrowVector< T >::pop_back(), DocSimpleSect::Post, DocSimpleSect::Pre, DocSimpleSect::Remark, DocSimpleSect::Return, DocParamSect::RetVal, DocInclude::RtfInclude, DocVerbatim::RtfOnly, DocParserContext::scope, TokenInfo::sectionId, DocSimpleSect::See, DocVerbatim::setEngine(), DocTokenizer::setStateCode(), DocTokenizer::setStateDbOnly(), DocTokenizer::setStateDot(), DocTokenizer::setStateHtmlOnly(), DocTokenizer::setStateICode(), DocTokenizer::setStateILiteral(), DocTokenizer::setStateILiteralOpt(), DocTokenizer::setStateIVerbatim(), DocTokenizer::setStateLatexOnly(), DocTokenizer::setStateManOnly(), DocTokenizer::setStateMermaid(), DocTokenizer::setStateMermaidOpt(), DocTokenizer::setStateMsc(), DocTokenizer::setStatePara(), DocTokenizer::setStatePlantUML(), DocTokenizer::setStatePlantUMLOpt(), DocTokenizer::setStateRtfOnly(), DocTokenizer::setStateSetScope(), DocTokenizer::setStateVerbatim(), DocTokenizer::setStateXmlOnly(), DocSimpleSect::Since, DocIncOperator::Skip, DocIncOperator::SkipLine, DocInclude::Snippet, DocInclude::SnippetWithLines, split(), DString::str(), stripLeadingAndTrailingEmptyLines(), DString::stripWhiteSpace(), HtmlEntityMapper::Sym_Amp, HtmlEntityMapper::Sym_At, HtmlEntityMapper::Sym_BSlash, HtmlEntityMapper::Sym_Dollar, HtmlEntityMapper::Sym_Dot, HtmlEntityMapper::Sym_DoubleColon, HtmlEntityMapper::Sym_Equal, HtmlEntityMapper::Sym_Exclam, HtmlEntityMapper::Sym_Greater, HtmlEntityMapper::Sym_Hash, HtmlEntityMapper::Sym_Less, HtmlEntityMapper::Sym_Minus, HtmlEntityMapper::Sym_Percent, HtmlEntityMapper::Sym_Pipe, HtmlEntityMapper::Sym_Plus, HtmlEntityMapper::Sym_Quest, HtmlEntityMapper::Sym_Quot, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, UNKNOWN, DocIncOperator::Until, DocSimpleSect::User, TokenInfo::verb, DocVerbatim::Verbatim, DocInclude::VerbInclude, DocSimpleSect::Version, DString::view(), warn, warn_doc_error, DocSimpleSect::Warning, DocInclude::XmlInclude, and DocVerbatim::XmlOnly.

Referenced by parse().

◆ handleDoxyConfig()

void DocPara::handleDoxyConfig ( char cmdChar,
const DString & cmdName )

Definition at line 3668 of file docnode.cpp.

3669{
3670 // get the argument of the cite command.
3671 Token tok=parser()->tokenizer.lex();
3672 if (!tok.is(TokenRetval::TK_WHITESPACE))
3673 {
3674 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3675 cmdChar,cmdName);
3676 return;
3677 }
3678 parser()->tokenizer.setStateDoxyConfig();
3679 tok=parser()->tokenizer.lex();
3680 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3681 {
3682 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3683 "argument of command '{:c}{}'",cmdChar,cmdName);
3684 return;
3685 }
3686 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3687 {
3688 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3689 tok.to_string(),cmdChar,cmdName);
3690 return;
3691 }
3692 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3693 if (opt)
3694 {
3695 DString optionValue;
3696 switch (opt->kind())
3697 {
3698 case ConfigOption::O_Bool:
3699 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3700 break;
3701 case ConfigOption::O_String:
3702 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3703 break;
3704 case ConfigOption::O_Enum:
3705 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3706 break;
3707 case ConfigOption::O_Int:
3708 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3709 break;
3710 case ConfigOption::O_List:
3711 {
3712 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3713 optionValue="";
3714 if (!lst->empty())
3715 {
3716 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3717 static const reg::Ex marker(R"(@(\d+))");
3718 reg::Iterator it(lstFormat,marker);
3719 reg::Iterator end;
3720 size_t index=0;
3721 // now replace all markers with the real text
3722 for ( ; it!=end ; ++it)
3723 {
3724 const auto &match = *it;
3725 size_t newIndex = match.position();
3726 size_t matchLen = match.length();
3727 optionValue += lstFormat.substr(index,newIndex-index);
3728 unsigned long entryIndex = std::stoul(match[1].str());
3729 if (entryIndex<(unsigned long)lst->size())
3730 {
3731 optionValue += lst->at(entryIndex);
3732 }
3733 index=newIndex+matchLen;
3734 }
3735 optionValue+=lstFormat.substr(index);
3736 }
3737 }
3738 break;
3739 case ConfigOption::O_Obsolete:
3740 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3741 cmdChar,cmdName,parser()->context.token->name);
3742 break;
3743 case ConfigOption::O_Disabled:
3744 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3745 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3746 cmdChar,cmdName,parser()->context.token->name);
3747 break;
3748 case ConfigOption::O_Info:
3749 // nothing to show here
3750 break;
3751 }
3752 if (!optionValue.empty())
3753 {
3754 children().append<DocWord>(parser(),thisVariant(),optionValue);
3755 }
3756 }
3757 else
3758 {
3759 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3760 cmdChar,cmdName,parser()->context.token->name);
3761 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3762 }
3763 parser()->tokenizer.setStatePara();
3764}
ConfigImpl::instance
static ConfigImpl * instance()
Definition configimpl.h:347
ConfigImpl::get
ConfigOption * get(const DString &name) const
Definition configimpl.h:396
ConfigOption::O_Disabled
@ O_Disabled
Disabled compile time option.
Definition configimpl.h:51
ConfigOption::O_List
@ O_List
A list of items.
Definition configimpl.h:45
ConfigOption::O_Enum
@ O_Enum
A fixed set of items.
Definition configimpl.h:46
ConfigOption::O_Bool
@ O_Bool
A boolean value.
Definition configimpl.h:49
ConfigOption::O_String
@ O_String
A single item.
Definition configimpl.h:47
ConfigOption::O_Obsolete
@ O_Obsolete
An obsolete option.
Definition configimpl.h:50
ConfigOption::O_Int
@ O_Int
An integer value.
Definition configimpl.h:48
ConfigOption::O_Info
@ O_Info
A section header.
Definition configimpl.h:44
ConfigOption::kind
OptionType kind() const
Definition configimpl.h:66
DString::substr
DString substr(size_t pos=0, size_t count=npos) const
Returns a substring of length count starting at pos.
Definition dstring.h:223
DocTokenizer::setStateDoxyConfig
void setStateDoxyConfig()
Definition doctokenizer.l:2129
Token::is
bool is(TokenRetval rv) const
Definition doctokenizer.h:119
Token::to_string
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
Definition doctokenizer.h:90
Token::is_any_of
bool is_any_of(ARGS... args) const
Definition doctokenizer.h:114
Translator::trWriteList
virtual DString trWriteList(int numEntries)=0
end
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:181
theTranslator
Translator * theTranslator
Definition language.cpp:76
reg::match
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:861

References DocNodeList::append(), DocCompoundNode::children(), DocParser::context, DString::empty(), end(), ConfigImpl::get(), ConfigImpl::instance(), Token::is(), Token::is_any_of(), ConfigOption::kind(), DocTokenizer::lex(), TokenInfo::name, ConfigOption::O_Bool, ConfigOption::O_Disabled, ConfigOption::O_Enum, ConfigOption::O_Info, ConfigOption::O_Int, ConfigOption::O_List, ConfigOption::O_Obsolete, ConfigOption::O_String, DocNode::parser(), DocTokenizer::setStateDoxyConfig(), DocTokenizer::setStatePara(), DString::str(), DString::substr(), theTranslator, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Translator::trWriteList(), ConfigEnum::valueRef(), ConfigString::valueRef(), ConfigBool::valueStringRef(), ConfigInt::valueStringRef(), warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleEmoji()

void DocPara::handleEmoji ( char cmdChar,
const DString & cmdName )

Definition at line 3637 of file docnode.cpp.

3638{
3639 AUTO_TRACE();
3640 // get the argument of the emoji command.
3641 Token tok=parser()->tokenizer.lex();
3642 if (!tok.is(TokenRetval::TK_WHITESPACE))
3643 {
3644 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3645 cmdChar,cmdName);
3646 return;
3647 }
3648 parser()->tokenizer.setStateEmoji();
3649 tok=parser()->tokenizer.lex();
3650 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3651 {
3652 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3653 "argument of command '{:c}{}'",cmdChar,cmdName);
3654 parser()->tokenizer.setStatePara();
3655 return;
3656 }
3657 else if (!tok.is(TokenRetval::TK_WORD))
3658 {
3659 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3660 tok.to_string(),cmdChar,cmdName);
3661 parser()->tokenizer.setStatePara();
3662 return;
3663 }
3664 children().append<DocEmoji>(parser(),thisVariant(),parser()->context.token->name);
3665 parser()->tokenizer.setStatePara();
3666}
DocTokenizer::setStateEmoji
void setStateEmoji()
Definition doctokenizer.l:2210

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, Token::is(), Token::is_any_of(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStateEmoji(), DocTokenizer::setStatePara(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleFile()

template<class T>
void DocPara::handleFile ( const DString & cmdName)

Definition at line 3918 of file docnode.cpp.

3919{
3920 AUTO_TRACE("cmdName={}",cmdName);
3921 DString saveCmdName = cmdName;
3922 Token tok=parser()->tokenizer.lex();
3923 if (!tok.is(TokenRetval::TK_WHITESPACE))
3924 {
3925 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3926 saveCmdName);
3927 return;
3928 }
3929 parser()->tokenizer.setStateFile();
3930 tok=parser()->tokenizer.lex();
3931 parser()->tokenizer.setStatePara();
3932 if (!tok.is(TokenRetval::TK_WORD))
3933 {
3934 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3935 tok.to_string(),saveCmdName);
3936 return;
3937 }
3938 DString name = parser()->context.token->name;
3939 children().append<T>(parser(),thisVariant(),name,
3940 parser()->context.context,
3941 parser()->context.fileName,
3942 parser()->tokenizer.getLineNr());
3943 auto df = children().get_last<T>();
3944 if (!df->parse())
3945 {
3946 children().pop_back();
3947 }
3948}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2093
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2302
LatexSections::name
const char * name(int level)
Definition latexgen.h:368

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, DocParserContext::context, DocParserContext::fileName, DocNodeList::get_last(), DocTokenizer::getLineNr(), Token::is(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), GrowVector< T >::pop_back(), DocTokenizer::setStateFile(), DocTokenizer::setStatePara(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleHtmlEndTag()

Token DocPara::handleHtmlEndTag ( const DString & tagName)

Definition at line 5509 of file docnode.cpp.

5510{
5511 AUTO_TRACE("tagName={}",tagName);
5512 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5513 Token retval = Token::make_RetVal_OK();
5514 switch (tagId)
5515 {
5516 case HtmlTagType::HTML_UL:
5517 if (!insideUL(thisVariant()))
5518 {
5519 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5520 }
5521 else
5522 {
5523 retval = Token::make_RetVal_EndList();
5524 }
5525 break;
5526 case HtmlTagType::HTML_OL:
5527 if (!insideOL(thisVariant()))
5528 {
5529 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5530 }
5531 else
5532 {
5533 retval = Token::make_RetVal_EndList();
5534 }
5535 break;
5536 case HtmlTagType::HTML_LI:
5537 if (!insideLI(thisVariant()))
5538 {
5539 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5540 }
5541 else
5542 {
5543 // ignore </li> tags
5544 }
5545 break;
5546 case HtmlTagType::HTML_DETAILS:
5547 if (!insideDetails(thisVariant()))
5548 {
5549 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5550 }
5551 else
5552 {
5553 retval = Token::make_RetVal_EndHtmlDetails();
5554 }
5555 break;
5556 case HtmlTagType::HTML_BLOCKQUOTE:
5557 if (!insideBlockQuote(thisVariant()))
5558 {
5559 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5560 }
5561 else
5562 {
5563 retval = Token::make_RetVal_EndBlockQuote();
5564 }
5565 break;
5566 case HtmlTagType::HTML_BOLD:
5567 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Bold,tagName);
5568 break;
5569 case HtmlTagType::HTML_S:
5570 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::S,"s");
5571 break;
5572 case HtmlTagType::HTML_STRIKE:
5573 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Strike,tagName);
5574 break;
5575 case HtmlTagType::HTML_DEL:
5576 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Del,tagName);
5577 break;
5578 case HtmlTagType::HTML_UNDERLINE:
5579 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Underline,tagName);
5580 break;
5581 case HtmlTagType::HTML_INS:
5582 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Ins,tagName);
5583 break;
5584 case HtmlTagType::HTML_CODE:
5585 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5586 break;
5587 case HtmlTagType::HTML_KBD:
5588 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Kbd,tagName);
5589 break;
5590 case HtmlTagType::HTML_TT:
5591 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Typewriter,tagName);
5592 break;
5593 case HtmlTagType::HTML_EMPHASIS:
5594 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Italic,tagName);
5595 break;
5596 case HtmlTagType::HTML_DIV:
5597 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5598 break;
5599 case HtmlTagType::HTML_SPAN:
5600 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5601 break;
5602 case HtmlTagType::HTML_SUB:
5603 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Subscript,tagName);
5604 break;
5605 case HtmlTagType::HTML_SUP:
5606 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Superscript,tagName);
5607 break;
5608 case HtmlTagType::HTML_CENTER:
5609 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Center,tagName);
5610 break;
5611 case HtmlTagType::HTML_SMALL:
5612 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Small,tagName);
5613 break;
5614 case HtmlTagType::HTML_CITE:
5615 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Cite,tagName);
5616 break;
5617 case HtmlTagType::HTML_PRE:
5618 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Preformatted,tagName);
5619 setInsidePreformatted(false);
5620 parser()->tokenizer.setInsidePre(false);
5621 break;
5622 case HtmlTagType::HTML_P:
5623 retval = Token::make_TK_NEWPARA();
5624 break;
5625 case HtmlTagType::HTML_DL:
5626 retval = Token::make_RetVal_EndDesc();
5627 break;
5628 case HtmlTagType::HTML_DT:
5629 // ignore </dt> tag
5630 break;
5631 case HtmlTagType::HTML_DD:
5632 // ignore </dd> tag
5633 break;
5634 case HtmlTagType::HTML_TABLE:
5635 retval = Token::make_RetVal_EndTable();
5636 break;
5637 case HtmlTagType::HTML_TR:
5638 retval = Token::make_RetVal_EndTableRow();
5639 break;
5640 case HtmlTagType::HTML_TD:
5641 retval = Token::make_RetVal_EndTableCell();
5642 break;
5643 case HtmlTagType::HTML_TH:
5644 retval = Token::make_RetVal_EndTableCell();
5645 break;
5646 case HtmlTagType::HTML_THEAD:
5647 case HtmlTagType::HTML_TBODY:
5648 case HtmlTagType::HTML_TFOOT:
5649 // for time being ignore </t....> tag
5650 break;
5651 case HtmlTagType::HTML_CAPTION:
5652 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5653 break;
5654 case HtmlTagType::HTML_BR:
5655 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5656 break;
5657 case HtmlTagType::HTML_H1:
5658 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5659 break;
5660 case HtmlTagType::HTML_H2:
5661 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5662 break;
5663 case HtmlTagType::HTML_H3:
5664 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5665 break;
5666 case HtmlTagType::HTML_H4:
5667 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5668 break;
5669 case HtmlTagType::HTML_H5:
5670 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5671 break;
5672 case HtmlTagType::HTML_H6:
5673 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5674 break;
5675 case HtmlTagType::HTML_IMG:
5676 break;
5677 case HtmlTagType::HTML_HR:
5678 // warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5679 break;
5680 case HtmlTagType::HTML_A:
5681 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5682 // ignore </a> tag (can be part of <a name=...></a>
5683 break;
5684
5685 case HtmlTagType::XML_TERM:
5686 break;
5687 case HtmlTagType::XML_SUMMARY:
5688 retval = Token::make_TK_NEWPARA();
5689 break;
5690 case HtmlTagType::XML_REMARKS:
5691 case HtmlTagType::XML_PARA:
5692 case HtmlTagType::XML_VALUE:
5693 case HtmlTagType::XML_EXAMPLE:
5694 case HtmlTagType::XML_PARAM:
5695 case HtmlTagType::XML_LIST:
5696 case HtmlTagType::XML_TYPEPARAM:
5697 case HtmlTagType::XML_RETURNS:
5698 case HtmlTagType::XML_SEE:
5699 case HtmlTagType::XML_SEEALSO:
5700 case HtmlTagType::XML_EXCEPTION:
5701 case HtmlTagType::XML_INHERITDOC:
5702 retval = Token::make_RetVal_CloseXml();
5703 break;
5704 case HtmlTagType::XML_C:
5705 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5706 break;
5707 case HtmlTagType::XML_ITEM:
5708 case HtmlTagType::XML_LISTHEADER:
5709 case HtmlTagType::XML_INCLUDE:
5710 case HtmlTagType::XML_PERMISSION:
5711 case HtmlTagType::XML_DESCRIPTION:
5712 case HtmlTagType::XML_PARAMREF:
5713 case HtmlTagType::XML_TYPEPARAMREF:
5714 // These tags are defined in .Net but are currently unsupported
5715 break;
5716 case HtmlTagType::UNKNOWN:
5717 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5718 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5719 break;
5720 default:
5721 // we should not get here!
5722 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5723 ASSERT(0);
5724 break;
5725 }
5726 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5727 return retval;
5728}
DocNode::setInsidePreformatted
void setInsidePreformatted(bool p)
Definition docnode.h:108
DocParser::handleStyleLeave
void handleStyleLeave(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const DString &tagName)
Definition docparser.cpp:718
DocTokenizer::setInsidePre
void setInsidePre(bool b)
Definition doctokenizer.l:2246
HtmlTagType
HtmlTagType
Definition cmdmapper.h:174
insideUL
bool insideUL(const DocNodeVariant *n)
Definition docparser_p.h:229
insideLI
bool insideLI(const DocNodeVariant *n)
Definition docparser_p.h:204
insideBlockQuote
bool insideBlockQuote(const DocNodeVariant *n)
Definition docparser_p.h:215
insideDetails
bool insideDetails(const DocNodeVariant *n)
Definition docparser_p.h:274
insideOL
bool insideOL(const DocNodeVariant *n)
Definition docparser_p.h:246
Mappers::htmlTagMapper
const Mapper< HtmlTagType > * htmlTagMapper
Definition cmdmapper.cpp:255

References DocNodeList::append(), ASSERT, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, DocStyleChange::Del, DocStyleChange::Div, DocParser::handleStyleLeave(), HTML_A, HTML_BLOCKQUOTE, HTML_BOLD, HTML_BR, HTML_CAPTION, HTML_CENTER, HTML_CITE, HTML_CODE, HTML_DD, HTML_DEL, HTML_DETAILS, HTML_DIV, HTML_DL, HTML_DT, HTML_EMPHASIS, HTML_H1, HTML_H2, HTML_H3, HTML_H4, HTML_H5, HTML_H6, HTML_HR, HTML_IMG, HTML_INS, HTML_KBD, HTML_LI, HTML_OL, HTML_P, HTML_PRE, HTML_S, HTML_SMALL, HTML_SPAN, HTML_STRIKE, HTML_SUB, HTML_SUP, HTML_TABLE, HTML_TBODY, HTML_TD, HTML_TFOOT, HTML_TH, HTML_THEAD, HTML_TR, HTML_TT, HTML_UL, HTML_UNDERLINE, Mappers::htmlTagMapper, DocStyleChange::Ins, insideBlockQuote(), insideDetails(), insideLI(), insideOL(), insideUL(), DocStyleChange::Italic, DocStyleChange::Kbd, DocNode::parser(), DocStyleChange::Preformatted, DocStyleChange::S, DocTokenizer::setInsidePre(), DocNode::setInsidePreformatted(), DocStyleChange::Small, DocStyleChange::Span, DocStyleChange::Strike, DocStyleChange::Subscript, DocStyleChange::Superscript, DocNode::thisVariant(), Token::to_string(), DocParser::tokenizer, DocStyleChange::Typewriter, DocStyleChange::Underline, UNKNOWN, warn_doc_error, XML_C, XML_DESCRIPTION, XML_EXAMPLE, XML_EXCEPTION, XML_INCLUDE, XML_INHERITDOC, XML_ITEM, XML_LIST, XML_LISTHEADER, XML_PARA, XML_PARAM, XML_PARAMREF, XML_PERMISSION, XML_REMARKS, XML_RETURNS, XML_SEE, XML_SEEALSO, XML_SUMMARY, XML_TERM, XML_TYPEPARAM, XML_TYPEPARAMREF, and XML_VALUE.

Referenced by parse().

◆ handleHtmlHeader()

Token DocPara::handleHtmlHeader ( const HtmlAttribList & tagHtmlAttribs,
int level )

Definition at line 4134 of file docnode.cpp.

4135{
4136 AUTO_TRACE();
4137 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4138 Token retval = children().get_last<DocHtmlHeader>()->parse();
4139 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4140}

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocNodeList::get_last(), parse(), DocNode::parser(), and DocNode::thisVariant().

Referenced by handleHtmlStartTag().

◆ handleHtmlStartTag()

Token DocPara::handleHtmlStartTag ( const DString & tagName,
const HtmlAttribList & tagHtmlAttribs )

Definition at line 5039 of file docnode.cpp.

5040{
5041 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
5042 Token retval = Token::make_RetVal_OK();
5043 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5044 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
5045 tagId!=HtmlTagType::UNKNOWN && tagId!=HtmlTagType::HTML_IMG && tagId!=HtmlTagType::HTML_BR && tagId!=HtmlTagType::HTML_HR && tagId!=HtmlTagType::HTML_P
5046 && tagId!=HtmlTagType::HTML_DIV && tagId!=HtmlTagType::HTML_SPAN)
5047 {
5048 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
5049 tagName);
5050 }
5051 switch (tagId)
5052 {
5053 case HtmlTagType::HTML_UL:
5054 if (!parser()->context.token->emptyTag)
5055 {
5056 children().append<DocHtmlList>(parser(),thisVariant(),
5057 tagHtmlAttribs,DocHtmlList::Unordered);
5058 retval=children().get_last<DocHtmlList>()->parse();
5059 }
5060 break;
5061 case HtmlTagType::HTML_OL:
5062 if (!parser()->context.token->emptyTag)
5063 {
5064 children().append<DocHtmlList>(parser(),thisVariant(),
5065 tagHtmlAttribs,DocHtmlList::Ordered);
5066 retval=children().get_last<DocHtmlList>()->parse();
5067 }
5068 break;
5069 case HtmlTagType::HTML_LI:
5070 if (parser()->context.token->emptyTag) break;
5071 if (!insideUL(thisVariant()) && !insideOL(thisVariant()))
5072 {
5073 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
5074 }
5075 else
5076 {
5077 retval = Token::make_RetVal_ListItem();
5078 }
5079 break;
5080 case HtmlTagType::HTML_BOLD:
5081 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
5082 break;
5083 case HtmlTagType::HTML_S:
5084 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
5085 break;
5086 case HtmlTagType::HTML_STRIKE:
5087 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
5088 break;
5089 case HtmlTagType::HTML_DEL:
5090 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
5091 break;
5092 case HtmlTagType::HTML_UNDERLINE:
5093 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
5094 break;
5095 case HtmlTagType::HTML_INS:
5096 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
5097 break;
5098 case HtmlTagType::HTML_CODE:
5099 if (parser()->context.token->emptyTag) break;
5100 if (parser()->context.xmlComment)
5101 // for C# source or inside a <summary> or <remark> section we
5102 // treat <code> as an XML tag (so similar to @code)
5103 {
5104 parser()->tokenizer.setStateXmlCode();
5105 retval = handleStartCode();
5106 }
5107 else // normal HTML markup
5108 {
5109 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5110 }
5111 break;
5112 case HtmlTagType::HTML_KBD:
5113 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
5114 break;
5115 case HtmlTagType::HTML_TT:
5116 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
5117 break;
5118 case HtmlTagType::HTML_EMPHASIS:
5119 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
5120 break;
5121 case HtmlTagType::HTML_DIV:
5122 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
5123 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5124 break;
5125 case HtmlTagType::HTML_SPAN:
5126 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5127 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5128 break;
5129 case HtmlTagType::HTML_SUB:
5130 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5131 break;
5132 case HtmlTagType::HTML_SUP:
5133 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5134 break;
5135 case HtmlTagType::HTML_CENTER:
5136 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5137 break;
5138 case HtmlTagType::HTML_SMALL:
5139 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5140 break;
5141 case HtmlTagType::HTML_CITE:
5142 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5143 break;
5144 case HtmlTagType::HTML_PRE:
5145 if (parser()->context.token->emptyTag) break;
5146 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5147 setInsidePreformatted(true);
5148 parser()->tokenizer.setInsidePre(true);
5149 break;
5150 case HtmlTagType::HTML_P:
5151 retval = Token::make_TK_NEWPARA();
5152 break;
5153 case HtmlTagType::HTML_DL:
5154 if (!parser()->context.token->emptyTag)
5155 {
5156 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5157 retval=children().get_last<DocHtmlDescList>()->parse();
5158 }
5159 break;
5160 case HtmlTagType::HTML_DT:
5161 if (insideDL(thisVariant()))
5162 {
5163 retval = Token::make_RetVal_DescTitle();
5164 }
5165 else
5166 {
5167 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5168 }
5169 break;
5170 case HtmlTagType::HTML_DD:
5171 if (insideDL(thisVariant()))
5172 {
5173 retval = Token::make_RetVal_DescData();
5174 }
5175 else
5176 {
5177 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5178 }
5179 break;
5180 case HtmlTagType::HTML_TABLE:
5181 if (!parser()->context.token->emptyTag)
5182 {
5183 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5184 retval=children().get_last<DocHtmlTable>()->parse();
5185 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5186 }
5187 break;
5188 case HtmlTagType::HTML_TR:
5189 retval = Token::make_RetVal_TableRow();
5190 break;
5191 case HtmlTagType::HTML_TD:
5192 retval = Token::make_RetVal_TableCell();
5193 break;
5194 case HtmlTagType::HTML_TH:
5195 retval = Token::make_RetVal_TableHCell();
5196 break;
5197 case HtmlTagType::HTML_THEAD:
5198 case HtmlTagType::HTML_TBODY:
5199 case HtmlTagType::HTML_TFOOT:
5200 // for time being ignore </t....> tag
5201 break;
5202 case HtmlTagType::HTML_CAPTION:
5203 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5204 break;
5205 case HtmlTagType::HTML_BR:
5206 {
5207 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5208 }
5209 break;
5210 case HtmlTagType::HTML_HR:
5211 {
5212 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5213 }
5214 break;
5215 case HtmlTagType::HTML_A:
5216 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5217 break;
5218 case HtmlTagType::HTML_H1:
5219 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5220 break;
5221 case HtmlTagType::HTML_H2:
5222 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5223 break;
5224 case HtmlTagType::HTML_H3:
5225 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5226 break;
5227 case HtmlTagType::HTML_H4:
5228 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5229 break;
5230 case HtmlTagType::HTML_H5:
5231 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5232 break;
5233 case HtmlTagType::HTML_H6:
5234 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5235 break;
5236 case HtmlTagType::HTML_IMG:
5237 {
5238 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5239 }
5240 break;
5241 case HtmlTagType::HTML_DETAILS:
5242 if (!parser()->context.token->emptyTag)
5243 {
5244 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5245 retval=children().get_last<DocHtmlDetails>()->parse();
5246 }
5247 break;
5248 case HtmlTagType::HTML_BLOCKQUOTE:
5249 if (!parser()->context.token->emptyTag)
5250 {
5251 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5252 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5253 }
5254 break;
5255
5256 case HtmlTagType::XML_SUMMARY:
5257 if (insideDetails(thisVariant()))
5258 {
5259 if (!parser()->context.token->emptyTag)
5260 {
5261 DocNodeVariant *n=parent();
5262 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5263 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5264 if (d)
5265 {
5266 if (!d->summary()) // details section does not have a summary yet
5267 {
5268 d->parseSummary(n,parser()->context.token->attribs);
5269 }
5270 else
5271 {
5272 retval = Token::make_TK_NEWPARA();
5273 }
5274 }
5275 }
5276 }
5277 break;
5278 case HtmlTagType::XML_REMARKS:
5279 case HtmlTagType::XML_EXAMPLE:
5280 parser()->context.xmlComment=true;
5281 // fall through
5282 case HtmlTagType::XML_VALUE:
5283 case HtmlTagType::XML_PARA:
5284 if (!children().empty())
5285 {
5286 retval = Token::make_TK_NEWPARA();
5287 }
5288 break;
5289 case HtmlTagType::XML_DESCRIPTION:
5290 if (insideTable(thisVariant()))
5291 {
5292 retval = Token::make_RetVal_TableCell();
5293 }
5294 break;
5295 case HtmlTagType::XML_C:
5296 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5297 break;
5298 case HtmlTagType::XML_PARAM:
5299 case HtmlTagType::XML_TYPEPARAM:
5300 {
5301 parser()->context.xmlComment=true;
5302 DString paramName;
5303 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5304 {
5305 if (paramName.empty())
5306 {
5307 if (Config_getBool(WARN_NO_PARAMDOC))
5308 {
5309 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5310 }
5311 }
5312 else
5313 {
5314 retval = handleParamSection(paramName,
5315 tagId==HtmlTagType::XML_PARAM ? DocParamSect::Param : DocParamSect::TemplateParam,
5316 true);
5317 }
5318 }
5319 else
5320 {
5321 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5322 }
5323 }
5324 break;
5325 case HtmlTagType::XML_PARAMREF:
5326 case HtmlTagType::XML_TYPEPARAMREF:
5327 {
5328 DString paramName;
5329 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5330 {
5331 //printf("paramName=%s\n",qPrint(paramName));
5332 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,true);
5333 children().append<DocWord>(parser(),thisVariant(),paramName);
5334 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,false);
5335 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5336 }
5337 else
5338 {
5339 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5340 }
5341 }
5342 break;
5343 case HtmlTagType::XML_EXCEPTION:
5344 {
5345 parser()->context.xmlComment=true;
5346 DString exceptName;
5347 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5348 {
5349 unescapeCRef(exceptName);
5350 retval = handleParamSection(exceptName,DocParamSect::Exception,true);
5351 }
5352 else
5353 {
5354 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5355 }
5356 }
5357 break;
5358 case HtmlTagType::XML_ITEM:
5359 case HtmlTagType::XML_LISTHEADER:
5360 if (insideTable(thisVariant()))
5361 {
5362 retval = Token::make_RetVal_TableRow();
5363 }
5364 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5365 {
5366 retval = Token::make_RetVal_ListItem();
5367 }
5368 else
5369 {
5370 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5371 }
5372 break;
5373 case HtmlTagType::XML_RETURNS:
5374 parser()->context.xmlComment=true;
5375 retval = handleSimpleSection(DocSimpleSect::Return,true);
5376 parser()->context.hasReturnCommand=true;
5377 break;
5378 case HtmlTagType::XML_TERM:
5379 if (insideTable(thisVariant()))
5380 {
5381 retval = Token::make_RetVal_TableCell();
5382 }
5383 break;
5384 case HtmlTagType::XML_SEE:
5385 // I'm not sure if <see> is the same as <seealso> or if it
5386 // should you link a member without producing a section. The
5387 // C# specification is extremely vague about this (but what else
5388 // can we expect from Microsoft...)
5389 {
5390 DString cref;
5391 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5392 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5393 {
5394 unescapeCRef(cref);
5395 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5396 {
5397 bool inSeeBlock = parser()->context.inSeeBlock;
5398 parser()->context.token->name = cref;
5399 parser()->context.inSeeBlock = true;
5400 parser()->handleLinkedWord(thisVariant(),children(),true);
5401 parser()->context.inSeeBlock = inSeeBlock;
5402 }
5403 else // <see cref="...">...</see> style
5404 {
5405 parser()->tokenizer.setStatePara();
5406 children().append<DocLink>(parser(),thisVariant(),cref);
5407 DocLink *lnk = children().get_last<DocLink>();
5408 DString leftOver = lnk->parse(false,true);
5409 if (!leftOver.empty())
5410 {
5411 children().append<DocWord>(parser(),thisVariant(),leftOver);
5412 }
5413 }
5414 }
5415 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5416 {
5417 bool inSeeBlock = parser()->context.inSeeBlock;
5418 parser()->context.token->name = cref;
5419 parser()->context.inSeeBlock = true;
5420 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,true);
5421 parser()->handleLinkedWord(thisVariant(),children(),true);
5422 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,false);
5423 parser()->context.inSeeBlock = inSeeBlock;
5424 }
5425 else
5426 {
5427 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5428 }
5429 }
5430 break;
5431 case HtmlTagType::XML_SEEALSO:
5432 {
5433 parser()->context.xmlComment=true;
5434 DString cref;
5435 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5436 {
5437 unescapeCRef(cref);
5438 // Look for an existing "see" section
5439 DocNodeVariant *vss=nullptr;
5440 for (auto &n : children())
5441 {
5442 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5443 if (candidate && candidate->type()==DocSimpleSect::See)
5444 {
5445 vss = &n;
5446 }
5447 }
5448
5449 if (!vss) // start new section
5450 {
5451 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5452 vss = &children().back();
5453 }
5454
5455 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5456 retval = Token::make_RetVal_OK();
5457 }
5458 else
5459 {
5460 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5461 }
5462 }
5463 break;
5464 case HtmlTagType::XML_LIST:
5465 {
5466 DString type;
5467 findAttribute(tagHtmlAttribs,"type",&type);
5468 DocHtmlList::Type listType = DocHtmlList::Unordered;
5469 HtmlAttribList emptyList;
5470 if (type=="number")
5471 {
5472 listType=DocHtmlList::Ordered;
5473 }
5474 if (type=="table")
5475 {
5476 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5477 retval=children().get_last<DocHtmlTable>()->parseXml();
5478 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5479 }
5480 else
5481 {
5482 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5483 retval=children().get_last<DocHtmlList>()->parseXml();
5484 }
5485 }
5486 break;
5487 case HtmlTagType::XML_INCLUDE:
5488 case HtmlTagType::XML_PERMISSION:
5489 // These tags are defined in .Net but are currently unsupported
5490 parser()->context.xmlComment=true;
5491 break;
5492 case HtmlTagType::UNKNOWN:
5493 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5494 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5495 break;
5496 case HtmlTagType::XML_INHERITDOC:
5497 handleInheritDoc();
5498 break;
5499 default:
5500 // we should not get here!
5501 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5502 ASSERT(0);
5503 break;
5504 }
5505 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5506 return retval;
5507}
DocHtmlDetails::parseSummary
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1574
DocHtmlDetails::summary
const DocNodeVariant * summary() const
Definition docnode.h:873
DocPara::empty
bool empty() const
Definition docnode.h:1093
DocPara::handleHtmlHeader
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4134
DocParser::handleAHref
Token handleAHref(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:799
DocParser::handleStyleEnter
void handleStyleEnter(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const DString &tagName, const HtmlAttribList *attribs)
Definition docparser.cpp:705
DocParser::handleLinkedWord
void handleLinkedWord(DocNodeVariant *parent, DocNodeList &children, bool ignoreAutoLinkFlag=false, bool typeLinkOnly=false)
Definition docparser.cpp:868
DocParser::handleImg
void handleImg(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:1868
DocSimpleSect::type
Type type() const
Definition docnode.h:1035
DocTokenizer::setStateXmlCode
void setStateXmlCode()
Definition doctokenizer.l:1939
GrowVector::back
T & back()
access the last element
Definition growvector.h:135
TokenInfo::attribsStr
DString attribsStr
Definition doctokenizer.h:165
findAttribute
static bool findAttribute(const HtmlAttribList &tagHtmlAttribs, const char *attrName, DString *result)
Definition docnode.cpp:5023
unescapeCRef
static void unescapeCRef(DString &s)
Definition docnode.cpp:97
DocNodeVariant
std::variant< DocWord, DocLinkedWord, DocURL, DocLineBreak, DocHorRuler, DocAnchor, DocCite, DocStyleChange, DocSymbol, DocEmoji, DocWhiteSpace, DocSeparator, DocVerbatim, DocInclude, DocIncOperator, DocFormula, DocIndexEntry, DocAutoList, DocAutoListItem, DocTitle, DocXRefItem, DocImage, DocDotFile, DocMscFile, DocDiaFile, DocVhdlFlow, DocLink, DocRef, DocInternalRef, DocHRef, DocHtmlHeader, DocHtmlDescTitle, DocHtmlDescList, DocSection, DocSecRefItem, DocSecRefList, DocInternal, DocParBlock, DocSimpleList, DocHtmlList, DocSimpleSect, DocSimpleSectSep, DocParamSect, DocPara, DocParamList, DocSimpleListItem, DocHtmlListItem, DocHtmlDescData, DocHtmlCell, DocHtmlCaption, DocHtmlRow, DocHtmlTable, DocHtmlBlockQuote, DocText, DocRoot, DocHtmlDetails, DocHtmlSummary, DocPlantUmlFile, DocMermaidFile > DocNodeVariant
Definition docnode.h:66
insideTable
bool insideTable(const DocNodeVariant *n)
Definition docparser_p.h:262
insideDL
bool insideDL(const DocNodeVariant *n)
Definition docparser_p.h:286

References DocNodeList::append(), ASSERT, TokenInfo::attribsStr, AUTO_TRACE, AUTO_TRACE_EXIT, GrowVector< T >::back(), DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, Config_getBool, DocParser::context, DocStyleChange::Del, DocStyleChange::Div, empty(), DString::empty(), DocParamSect::Exception, findAttribute(), DocNodeList::get_last(), DocParser::handleAHref(), handleHtmlHeader(), DocParser::handleImg(), handleInheritDoc(), DocParser::handleLinkedWord(), handleParamSection(), handleSimpleSection(), handleStartCode(), DocParser::handleStyleEnter(), DocParser::handleStyleLeave(), DocParserContext::hasReturnCommand, HTML_A, HTML_BLOCKQUOTE, HTML_BOLD, HTML_BR, HTML_CAPTION, HTML_CENTER, HTML_CITE, HTML_CODE, HTML_DD, HTML_DEL, HTML_DETAILS, HTML_DIV, HTML_DL, HTML_DT, HTML_EMPHASIS, HTML_H1, HTML_H2, HTML_H3, HTML_H4, HTML_H5, HTML_H6, HTML_HR, HTML_IMG, HTML_INS, HTML_KBD, HTML_LI, HTML_OL, HTML_P, HTML_PRE, HTML_S, HTML_SMALL, HTML_SPAN, HTML_STRIKE, HTML_SUB, HTML_SUP, HTML_TABLE, HTML_TBODY, HTML_TD, HTML_TFOOT, HTML_TH, HTML_THEAD, HTML_TR, HTML_TT, HTML_UL, HTML_UNDERLINE, Mappers::htmlTagMapper, DocStyleChange::Ins, DocParserContext::inSeeBlock, insideDetails(), insideDL(), insideOL(), insideTable(), insideUL(), Token::is(), DocStyleChange::Italic, DocStyleChange::Kbd, TokenInfo::name, DocParserContext::nodeStack, DocHtmlList::Ordered, DocParamSect::Param, DocNode::parent(), parse(), DocNode::parser(), DocHtmlDetails::parseSummary(), GrowVector< T >::pop_back(), DocStyleChange::Preformatted, DocSimpleSect::Return, DocStyleChange::S, DocSimpleSect::See, DocTokenizer::setInsidePre(), DocNode::setInsidePreformatted(), DocTokenizer::setStatePara(), DocTokenizer::setStateXmlCode(), DocStyleChange::Small, DocStyleChange::Span, DocStyleChange::Strike, DocStyleChange::Subscript, DocHtmlDetails::summary(), DocStyleChange::Superscript, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, DocSimpleSect::type(), DocStyleChange::Typewriter, DocStyleChange::Underline, unescapeCRef(), UNKNOWN, DocHtmlList::Unordered, warn_doc_error, XML_C, XML_CmdMask, XML_DESCRIPTION, XML_EXAMPLE, XML_EXCEPTION, XML_INCLUDE, XML_INHERITDOC, XML_ITEM, XML_LIST, XML_LISTHEADER, XML_PARA, XML_PARAM, XML_PARAMREF, XML_PERMISSION, XML_REMARKS, XML_RETURNS, XML_SEE, XML_SEEALSO, XML_SUMMARY, XML_TERM, XML_TYPEPARAM, XML_TYPEPARAMREF, XML_VALUE, and DocParserContext::xmlComment.

Referenced by parse().

◆ handleInclude()

void DocPara::handleInclude ( const DString & cmdName,
DocInclude::Type t )

Definition at line 3998 of file docnode.cpp.

3999{
4000 AUTO_TRACE("cmdName={}",cmdName);
4001 DString saveCmdName = cmdName;
4002 Token tok=parser()->tokenizer.lex();
4003 bool isBlock = false;
4004 bool trimLeft = false;
4005 bool localScope = false;
4006 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
4007 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
4008 {
4009 parser()->tokenizer.setStateOptions();
4010 parser()->tokenizer.lex();
4011 parser()->tokenizer.setStatePara();
4012 StringVector optList=split(parser()->context.token->name.str(),",");
4013 auto contains = [&optList](const char *kw)
4014 {
4015 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
4016 };
4017 localScope = contains("local");
4018 if (contains("nostrip"))
4019 {
4020 stripCodeComments = false;
4021 }
4022 else if (contains("strip"))
4023 {
4024 stripCodeComments = true;
4025 }
4026 if (t==DocInclude::Snippet && contains("trimleft"))
4027 {
4028 trimLeft = true;
4029 }
4030
4031 if (contains("lineno"))
4032 {
4033 if (t==DocInclude::Include) t = DocInclude::IncWithLines;
4034 else if (t==DocInclude::Snippet) t = DocInclude::SnippetWithLines;
4035 else if (t==DocInclude::DontInclude) t = DocInclude::DontIncWithLines;
4036 }
4037 tok=parser()->tokenizer.lex();
4038 if (!tok.is(TokenRetval::TK_WHITESPACE))
4039 {
4040 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4041 saveCmdName);
4042 return;
4043 }
4044 }
4045 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
4046 {
4047 parser()->tokenizer.setStateBlock();
4048 parser()->tokenizer.lex();
4049 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
4050 parser()->tokenizer.setStatePara();
4051 parser()->tokenizer.lex();
4052 }
4053 else if (!tok.is(TokenRetval::TK_WHITESPACE))
4054 {
4055 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4056 saveCmdName);
4057 return;
4058 }
4059 parser()->tokenizer.setStateFile();
4060 tok=parser()->tokenizer.lex();
4061 parser()->tokenizer.setStatePara();
4062 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4063 {
4064 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4065 "argument of command {}",saveCmdName);
4066 return;
4067 }
4068 else if (!tok.is(TokenRetval::TK_WORD))
4069 {
4070 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
4071 tok.to_string(),saveCmdName);
4072 return;
4073 }
4074 DString fileName = parser()->context.token->name;
4075 DString blockId;
4076 if (t==DocInclude::Snippet || t==DocInclude::SnippetWithLines)
4077 {
4078 if (fileName == "this") fileName=parser()->context.fileName;
4079 parser()->tokenizer.setStateSnippet();
4080 tok=parser()->tokenizer.lex();
4081 parser()->tokenizer.setStatePara();
4082 if (!tok.is(TokenRetval::TK_WORD))
4083 {
4084 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
4085 tok.to_string(),saveCmdName);
4086 return;
4087 }
4088 blockId = "["+parser()->context.token->name+"]";
4089 }
4090
4091 children().append<DocInclude>(parser(),
4092 thisVariant(),
4093 fileName,
4094 localScope ? parser()->context.context : "",
4095 t,
4096 stripCodeComments,
4097 parser()->context.isExample,
4098 parser()->context.exampleName,
4099 blockId,isBlock,trimLeft);
4100 children().get_last<DocInclude>()->parse();
4101}
DocInclude::DontIncWithLines
@ DontIncWithLines
Definition docnode.h:439
DocTokenizer::setStateSnippet
void setStateSnippet()
Definition doctokenizer.l:2179
DocTokenizer::setStateBlock
void setStateBlock()
Definition doctokenizer.l:2202
DocTokenizer::setStateOptions
void setStateOptions()
Definition doctokenizer.l:2194

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), Config_getBool, DocParser::context, DocParserContext::context, DocInclude::DontInclude, DocInclude::DontIncWithLines, DocParserContext::exampleName, DocParserContext::fileName, DocNodeList::get_last(), DocInclude::Include, DocInclude::IncWithLines, Token::is(), Token::is_any_of(), DocParserContext::isExample, DocTokenizer::lex(), TokenInfo::name, parse(), DocNode::parser(), DocTokenizer::setStateBlock(), DocTokenizer::setStateFile(), DocTokenizer::setStateOptions(), DocTokenizer::setStatePara(), DocTokenizer::setStateSnippet(), DocInclude::Snippet, DocInclude::SnippetWithLines, split(), DString::stripWhiteSpace(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleIncludeOperator()

void DocPara::handleIncludeOperator ( const DString & cmdName,
DocIncOperator::Type t )

Definition at line 3858 of file docnode.cpp.

3859{
3860 AUTO_TRACE("cmdName={}",cmdName);
3861 DString saveCmdName = cmdName;
3862 Token tok=parser()->tokenizer.lex();
3863 if (!tok.is(TokenRetval::TK_WHITESPACE))
3864 {
3865 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3866 saveCmdName);
3867 return;
3868 }
3869 parser()->tokenizer.setStatePattern();
3870 tok=parser()->tokenizer.lex();
3871 parser()->tokenizer.setStatePara();
3872 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3873 {
3874 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3875 "argument of command {}", saveCmdName);
3876 return;
3877 }
3878 else if (!tok.is(TokenRetval::TK_WORD))
3879 {
3880 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3881 tok.to_string(),saveCmdName);
3882 return;
3883 }
3884 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3885 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3886 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3887 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3888 //TODO get from context the stripCodeComments()
3889 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3890 children().append<DocIncOperator>(parser(),thisVariant(),t,
3891 parser()->context.token->name,
3892 parser()->context.context,
3893 stripCodeComments,
3894 parser()->context.isExample,
3895 parser()->context.exampleName
3896 );
3897 DocIncOperator *op = children().get_last<DocIncOperator>();
3898 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3899 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3900 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3901 bool isFirst = !n1 || // no last node
3902 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3903 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3904 op->markFirst(isFirst);
3905 op->markLast(true);
3906 if (n1_docIncOp)
3907 {
3908 n1_docIncOp->markLast(false);
3909 }
3910 else if (n1_docWs && n2_docIncOp)
3911 {
3912 n2_docIncOp->markLast(false);
3913 }
3914 op->parse();
3915}
DocIncOperator::markLast
void markLast(bool v=true)
Definition docnode.h:505
DocPara::isFirst
bool isFirst() const
Definition docnode.h:1096
DocTokenizer::setStatePattern
void setStatePattern()
Definition doctokenizer.l:2107
GrowVector::size
size_t size() const
returns the number of elements
Definition growvector.h:93
GrowVector::end
iterator end()
returns an iterator to the end
Definition growvector.h:88

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), Config_getBool, DocParser::context, DocParserContext::context, end(), GrowVector< T >::end(), DocParserContext::exampleName, DocNodeList::get_last(), Token::is(), Token::is_any_of(), DocParserContext::isExample, isFirst(), DocTokenizer::lex(), DocIncOperator::markLast(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), DocTokenizer::setStatePattern(), GrowVector< T >::size(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleInheritDoc()

void DocPara::handleInheritDoc ( )

Definition at line 4188 of file docnode.cpp.

4189{
4190 if (parser()->context.memberDef) // inheriting docs from a member
4191 {
4192 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4193 if (reMd) // member from which was inherited.
4194 {
4195 const MemberDef *thisMd = parser()->context.memberDef;
4196 bool hasParamCommand = false;
4197 bool hasReturnCommand = false;
4198 StringMultiSet retvalsFound;
4199 StringMultiSet paramsFound;
4200 { DocParser::AutoSaveContext saveContext(*parser());
4201 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4202 parser()->context.scope=reMd->getOuterScope();
4203 if (parser()->context.scope!=Doxygen::globalScope)
4204 {
4205 parser()->context.context=parser()->context.scope->name();
4206 }
4207 parser()->context.memberDef=reMd;
4208 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4209 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4210 parser()->context.copyStack.push_back(reMd);
4211 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4212 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4213 parser()->context.copyStack.pop_back();
4214 hasParamCommand = parser()->context.hasParamCommand;
4215 hasReturnCommand = parser()->context.hasReturnCommand;
4216 retvalsFound = parser()->context.retvalsFound;
4217 paramsFound = parser()->context.paramsFound;
4218 }
4219 parser()->context.hasParamCommand = hasParamCommand;
4220 parser()->context.hasReturnCommand = hasReturnCommand;
4221 parser()->context.retvalsFound = retvalsFound;
4222 parser()->context.paramsFound = paramsFound;
4223 parser()->context.memberDef = thisMd;
4224 }
4225 }
4226}
Definition::briefDescription
virtual DString briefDescription(bool abbreviate=false) const =0
Definition::documentation
virtual DString documentation() const =0
Definition::name
virtual const DString & name() const =0
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
DocParser::internalValidatingParseDoc
Token internalValidatingParseDoc(DocNodeVariant *parent, DocNodeList &children, const DString &doc)
Definition docparser.cpp:1899
MemberDef::reimplements
virtual const MemberDef * reimplements() const =0
StringMultiSet
std::multiset< std::string > StringMultiSet
Definition containers.h:32
DocParserContext::retvalsFound
StringMultiSet retvalsFound
Definition docparser_p.h:75
DocParserContext::styleStack
DocStyleChangeStack styleStack
Definition docparser_p.h:67
DocParserContext::paramsFound
StringMultiSet paramsFound
Definition docparser_p.h:76
DocParserContext::copyStack
DefinitionStack copyStack
Definition docparser_p.h:69

References Definition::briefDescription(), DocCompoundNode::children(), DocParser::context, DocParserContext::context, DocParserContext::copyStack, Definition::documentation(), Definition::getOuterScope(), Doxygen::globalScope, DocParserContext::hasParamCommand, DocParserContext::hasReturnCommand, DocParser::internalValidatingParseDoc(), DocParserContext::memberDef, Definition::name(), DocParserContext::nodeStack, DocParserContext::paramsFound, DocNode::parser(), MemberDef::reimplements(), DocParserContext::retvalsFound, DocParserContext::scope, DocParserContext::styleStack, and DocNode::thisVariant().

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleLink()

void DocPara::handleLink ( const DString & cmdName,
bool isJavaLink )

Definition at line 3957 of file docnode.cpp.

3958{
3959 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3960 DString saveCmdName = cmdName;
3961 Token tok=parser()->tokenizer.lex();
3962 if (!tok.is(TokenRetval::TK_WHITESPACE))
3963 {
3964 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3965 saveCmdName);
3966 return;
3967 }
3968 parser()->tokenizer.setStateLink();
3969 tok=parser()->tokenizer.lex();
3970 if (!tok.is(TokenRetval::TK_WORD))
3971 {
3972 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3973 tok.to_string(),saveCmdName);
3974 return;
3975 }
3976 if (saveCmdName == "javalink")
3977 {
3978 children().append<DocStyleChange>(parser(),thisVariant(),
3979 parser()->context.nodeStack.size(),
3980 DocStyleChange::Code,cmdName,true);
3981 }
3982 parser()->tokenizer.setStatePara();
3983 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3984 DocLink *lnk = children().get_last<DocLink>();
3985 if (saveCmdName == "javalink")
3986 {
3987 children().append<DocStyleChange>(parser(),thisVariant(),
3988 parser()->context.nodeStack.size(),
3989 DocStyleChange::Code,cmdName,false);
3990 }
3991 DString leftOver = lnk->parse(isJavaLink);
3992 if (!leftOver.empty())
3993 {
3994 children().append<DocWord>(parser(),thisVariant(),leftOver);
3995 }
3996}
DocTokenizer::setStateLink
void setStateLink()
Definition doctokenizer.l:2115

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocStyleChange::Code, DocParser::context, DString::empty(), DocNodeList::get_last(), Token::is(), DocTokenizer::lex(), TokenInfo::name, DocParserContext::nodeStack, DocNode::parser(), DocTokenizer::setStateLink(), DocTokenizer::setStatePara(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleParamSection()

Token DocPara::handleParamSection ( const DString & cmdName,
DocParamSect::Type t,
bool xmlContext = false,
int direction = DocParamSect::Unspecified )

Definition at line 3614 of file docnode.cpp.

3618{
3619 AUTO_TRACE();
3620 DocParamSect *ps = nullptr;
3621 if (!children().empty() && // previous element
3622 (ps=children().get_last<DocParamSect>()) && // was a param sect
3623 ps->type()==t) // of same type
3624 { // append to previous section ps
3625 }
3626 else // start new section
3627 {
3628 children().append<DocParamSect>(parser(),thisVariant(),t);
3629 ps = children().get_last<DocParamSect>();
3630 }
3631 Token rv=ps->parse(cmdName,xmlContext,
3632 static_cast<DocParamSect::Direction>(direction));
3633 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3634 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3635}
DocParamSect::parse
Token parse(const DString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3535
DocParamSect::type
Type type() const
Definition docnode.h:1077

References DocNodeList::append(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), empty(), DocNodeList::get_last(), Token::is(), DocParamSect::parse(), DocNode::parser(), DocNode::thisVariant(), Token::to_string(), DocParamSect::type(), and DocParamSect::Unspecified.

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleSection()

void DocPara::handleSection ( char cmdChar,
const DString & cmdName )

Definition at line 4103 of file docnode.cpp.

4104{
4105 AUTO_TRACE("cmdName={}",cmdName);
4106 DString saveCmdName = cmdName;
4107 // get the argument of the section command.
4108 Token tok=parser()->tokenizer.lex();
4109 if (!tok.is(TokenRetval::TK_WHITESPACE))
4110 {
4111 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4112 cmdChar,saveCmdName);
4113 return;
4114 }
4115 tok=parser()->tokenizer.lex();
4116 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4117 {
4118 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4119 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4120 return;
4121 }
4122 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4123 {
4124 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4125 tok.to_string(),cmdChar,saveCmdName);
4126 return;
4127 }
4128 parser()->context.token->sectionId = parser()->context.token->name;
4129 parser()->tokenizer.setStateSkipTitle();
4130 parser()->tokenizer.lex();
4131 parser()->tokenizer.setStatePara();
4132}
DocTokenizer::setStateSkipTitle
void setStateSkipTitle()
Definition doctokenizer.l:2158

References AUTO_TRACE, DocParser::context, Token::is(), Token::is_any_of(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), TokenInfo::sectionId, DocTokenizer::setStatePara(), DocTokenizer::setStateSkipTitle(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleShowDate()

void DocPara::handleShowDate ( char cmdChar,
const DString & cmdName )

Definition at line 3788 of file docnode.cpp.

3789{
3790 AUTO_TRACE();
3791 DString fmt;
3792 DString date;
3793 Token tok=parser()->tokenizer.lex();
3794 if (!tok.is(TokenRetval::TK_WHITESPACE))
3795 {
3796 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3797 cmdChar,cmdName);
3798 return;
3799 }
3800 parser()->tokenizer.setStateQuotedString();
3801 tok = parser()->tokenizer.lex();
3802 if (!tok.is(TokenRetval::TK_WORD))
3803 {
3804 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3805 cmdChar,cmdName);
3806 parser()->tokenizer.setStatePara();
3807 return;
3808 }
3809 fmt = parser()->context.token->name;
3810
3811 parser()->tokenizer.setStateShowDate();
3812 tok = parser()->tokenizer.lex();
3813
3814 DString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : DString();
3815 DString specDate = specDateRaw.stripWhiteSpace();
3816 bool specDateOnlyWS = !specDateRaw.empty() && specDate.empty();
3817 if (!specDate.empty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3818 {
3819 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3820 cmdChar,cmdName);
3821 parser()->tokenizer.setStatePara();
3822 return;
3823 }
3824
3825 std::tm dat{};
3826 int specFormat=0;
3827 DString err = dateTimeFromString(specDate,dat,specFormat);
3828 if (!err.empty())
3829 {
3830 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3831 cmdChar,cmdName,err);
3832 parser()->tokenizer.setStatePara();
3833 return;
3834 }
3835
3836 int usedFormat=0;
3837 DString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3838
3839 // warn the user if the format contains markers that are not explicitly filled in
3840 for (int i=0;i<SF_NumBits;i++)
3841 {
3842 int bitMask = 1<<i;
3843 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3844 {
3845 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"'{:c}{}' <format> parameter '{}' has {} related markers which are not specified in the <date_time> parameter '{}'. Filling in the current value for {} instead.",
3846 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3847 }
3848 }
3849
3850 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3851 if (specDateOnlyWS) // specDate is only whitespace
3852 {
3853 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3854 }
3855 parser()->tokenizer.setStatePara();
3856}
DocTokenizer::setStateShowDate
void setStateShowDate()
Definition doctokenizer.l:2232
DocTokenizer::setStateQuotedString
void setStateQuotedString()
Definition doctokenizer.l:2225
formatDateTime
DString formatDateTime(const DString &format, const std::tm &dt, int &formatUsed)
Return a string representation for a given std::tm value that is formatted according to the pattern g...
Definition datetime.cpp:176
dateTimeFromString
DString dateTimeFromString(const DString &spec, std::tm &dt, int &format)
Returns the filled in std::tm for a given string representing a date and/or time.
Definition datetime.cpp:135
SF_bit2str
constexpr const char * SF_bit2str(int bitNumber)
Helper function that returns the name related one of the SF bits.
Definition datetime.h:32
SF_NumBits
constexpr int SF_NumBits
number of bits in SF vector
Definition datetime.h:27
err
#define err(fmt,...)
Definition message.h:127

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, dateTimeFromString(), DString::empty(), err, formatDateTime(), Token::is(), Token::is_any_of(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), DocTokenizer::setStateQuotedString(), DocTokenizer::setStateShowDate(), SF_bit2str(), SF_NumBits, DString::stripWhiteSpace(), DocNode::thisVariant(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleSimpleSection()

Token DocPara::handleSimpleSection ( DocSimpleSect::Type t,
bool xmlContext = false )

Definition at line 3584 of file docnode.cpp.

3585{
3586 AUTO_TRACE();
3587 DocSimpleSect *ss=nullptr;
3588 bool needsSeparator = false;
3589 if (!children().empty() && // has previous element
3590 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3591 ss->type()==t && // of same type
3592 t!=DocSimpleSect::User) // but not user defined
3593 {
3594 // append to previous section
3595 needsSeparator = true;
3596 }
3597 else // start new section
3598 {
3599 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3600 ss = children().get_last<DocSimpleSect>();
3601 }
3602 Token rv = Token::make_RetVal_OK();
3603 if (xmlContext)
3604 {
3605 return ss->parseXml();
3606 }
3607 else
3608 {
3609 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3610 }
3611 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3612}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3244
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:3298

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), empty(), DocNodeList::get_last(), Token::is(), DocSimpleSect::parse(), DocNode::parser(), DocSimpleSect::parseXml(), DocNode::thisVariant(), DocSimpleSect::type(), and DocSimpleSect::User.

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 4152 of file docnode.cpp.

4153{
4154 AUTO_TRACE();
4155 Token retval = parser()->tokenizer.lex();
4156 DString lang = parser()->context.token->name;
4157 if (!lang.empty() && lang.at(0)!='.')
4158 {
4159 lang="."+lang;
4160 }
4161 if (parser()->context.xmlComment)
4162 {
4163 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4164 }
4165 // search for the first non-whitespace line, index is stored in li
4166 size_t i=0,li=0,l=parser()->context.token->verb.length();
4167 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4168 {
4169 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4170 i++;
4171 }
4172 children().append<DocVerbatim>(parser(),thisVariant(),
4173 parser()->context.context,
4174 stripIndentation(parser()->context.token->verb.mid(li)),
4175 DocVerbatim::Code,
4176 parser()->context.isExample,
4177 parser()->context.exampleName,
4178 false,lang);
4179 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4180 {
4181 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4182 }
4183 parser()->tokenizer.setStatePara();
4184 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4185 return retval;
4186}
DString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition dstring.h:686
DString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition dstring.h:151
substitute
DString substitute(const DString &s, const DString &src, const DString &dst)
substitute all occurrences of src in s by dst
Definition dstring.cpp:485
stripIndentation
DString stripIndentation(const DString &s, bool skipFirstLine)
Definition util.cpp:4693

References DocNodeList::append(), DString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), DocVerbatim::Code, DocParser::context, DocParserContext::context, DString::empty(), DocParserContext::exampleName, Token::is_any_of(), DocParserContext::isExample, DString::length(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), stripIndentation(), substitute(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TokenInfo::verb, and warn_doc_error.

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleVhdlFlow()

void DocPara::handleVhdlFlow ( )

Definition at line 3950 of file docnode.cpp.

3951{
3952 AUTO_TRACE();
3953 children().append<DocVhdlFlow>(parser(),thisVariant());
3954 children().get_last<DocVhdlFlow>()->parse();
3955}

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocNodeList::get_last(), parse(), DocNode::parser(), and DocNode::thisVariant().

Referenced by handleCommand().

◆ handleXRefItem()

Token DocPara::handleXRefItem ( )

Definition at line 3766 of file docnode.cpp.

3767{
3768 AUTO_TRACE();
3769 Token retval=parser()->tokenizer.lex();
3770 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3771 parser()->tokenizer.setStateXRefItem();
3772 retval=parser()->tokenizer.lex();
3773 if (retval.is(TokenRetval::RetVal_OK))
3774 {
3775 children().append<DocXRefItem>(parser(),thisVariant(),
3776 parser()->context.token->id,parser()->context.token->name);
3777 DocXRefItem *ref = children().get_last<DocXRefItem>();
3778 if (!ref->parse())
3779 {
3780 children().pop_back();
3781 }
3782 }
3783 parser()->tokenizer.setStatePara();
3784 return retval;
3785}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2086

References DocNodeList::append(), ASSERT, AUTO_TRACE, DocCompoundNode::children(), DocParser::context, DocNodeList::get_last(), TokenInfo::id, Token::is(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), GrowVector< T >::pop_back(), DocTokenizer::setStatePara(), DocTokenizer::setStateXRefItem(), DocNode::thisVariant(), DocParserContext::token, and DocParser::tokenizer.

Referenced by handleCommand().

◆ injectToken()

bool DocPara::injectToken ( Token tok,
const DString & tokText )

Definition at line 4145 of file docnode.cpp.

4146{
4147 AUTO_TRACE();
4148 parser()->context.token->name = tokText;
4149 return parser()->defaultHandleToken(thisVariant(),tok,children());
4150}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token &tok, DocNodeList &children, bool handleWord=true)
Definition docparser.cpp:1494

References AUTO_TRACE, DocCompoundNode::children(), DocParser::context, DocParser::defaultHandleToken(), TokenInfo::name, DocNode::parser(), DocNode::thisVariant(), and DocParserContext::token.

Referenced by DocSimpleSect::appendLinkWord().

◆ isFirst()

bool DocPara::isFirst ( ) const
inline

Definition at line 1096 of file docnode.h.

1096{ return m_isFirst; }

References m_isFirst.

Referenced by handleIncludeOperator(), and DocParser::internalValidatingParseDoc().

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1097 of file docnode.h.

1097{ return m_isLast; }

References m_isLast.

Referenced by DocParser::internalValidatingParseDoc(), LatexDocVisitor::operator()(), ManDocVisitor::operator()(), and RTFDocVisitor::operator()().

◆ markFirst()

void DocPara::markFirst ( bool v = true)
inline

Definition at line 1094 of file docnode.h.

1094{ m_isFirst=v; }

References m_isFirst.

Referenced by DocHtmlBlockQuote::parse(), DocHtmlCell::parse(), DocHtmlDescData::parse(), DocHtmlDetails::parse(), DocHtmlListItem::parse(), DocParamList::parse(), DocParBlock::parse(), DocSimpleListItem::parse(), DocHtmlCell::parseXml(), and DocHtmlListItem::parseXml().

◆ markLast()

void DocPara::markLast ( bool v = true)
inline

Definition at line 1095 of file docnode.h.

1095{ m_isLast=v; }

References m_isLast.

Referenced by DocParser::internalValidatingParseDoc(), DocAutoListItem::parse(), DocHtmlBlockQuote::parse(), DocHtmlCell::parse(), DocHtmlDescData::parse(), DocHtmlDetails::parse(), DocHtmlListItem::parse(), DocInternal::parse(), DocParamList::parse(), DocParBlock::parse(), DocRoot::parse(), DocSection::parse(), DocSimpleListItem::parse(), DocSimpleSect::parse(), DocHtmlCell::parseXml(), DocHtmlListItem::parseXml(), and DocSimpleSect::parseXml().

◆ parse()

Token DocPara::parse ( )

Definition at line 5782 of file docnode.cpp.

5783{
5784 AUTO_TRACE();
5785 auto ns = AutoNodeStack(parser(),thisVariant());
5786 // handle style commands "inherited" from the previous paragraph
5787 parser()->handleInitialStyleCommands(thisVariant(),children());
5788 Token tok=parser()->tokenizer.lex();
5789 Token retval = Token::make_TK_NONE();
5790 while (!tok.is_any_of(TokenRetval::TK_NONE, TokenRetval::TK_EOF)) // get the next token
5791 {
5792reparsetoken:
5793 AUTO_TRACE_ADD("token '{}' at {}",tok.to_string(),parser()->tokenizer.getLineNr());
5794 if (tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD,TokenRetval::TK_SYMBOL,TokenRetval::TK_URL,
5795 TokenRetval::TK_COMMAND_AT,TokenRetval::TK_COMMAND_BS,TokenRetval::TK_HTMLTAG)
5796 )
5797 {
5798 AUTO_TRACE_ADD("name={}",parser()->context.token->name);
5799 }
5800 switch(tok.value())
5801 {
5802 case TokenRetval::TK_WORD:
5803 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
5804 break;
5805 case TokenRetval::TK_LNKWORD:
5806 parser()->handleLinkedWord(thisVariant(),children());
5807 break;
5808 case TokenRetval::TK_URL:
5809 children().append<DocURL>(parser(),thisVariant(),parser()->context.token->name,parser()->context.token->isEMailAddr);
5810 break;
5811 case TokenRetval::TK_WHITESPACE:
5812 {
5813 // prevent leading whitespace and collapse multiple whitespace areas
5814 if (insidePRE(thisVariant()) || // all whitespace is relevant
5815 (
5816 // remove leading whitespace
5817 !children().empty() &&
5818 // and whitespace after certain constructs
5819 !holds_one_of_alternatives<DocHtmlDescList, DocHtmlTable, DocHtmlList, DocSimpleSect,
5820 DocAutoList, DocSimpleList, DocHtmlHeader, DocHtmlBlockQuote,
5821 DocParamSect, DocHtmlDetails, DocXRefItem>(children().back())
5822 )
5823 )
5824 {
5825 children().append<DocWhiteSpace>(parser(),thisVariant(),parser()->context.token->chars);
5826 }
5827 }
5828 break;
5829 case TokenRetval::TK_LISTITEM:
5830 {
5831 AUTO_TRACE_ADD("found list item at {}",parser()->context.token->indent);
5832 const DocNodeVariant *n=parent();
5833 while (n && !std::holds_alternative<DocAutoList>(*n)) n=::parent(n);
5834 const DocAutoList *al = std::get_if<DocAutoList>(n);
5835 if (al) // we found an auto list up in the hierarchy
5836 {
5837 AUTO_TRACE_ADD("previous list item at {}",al->indent());
5838 if (al->indent()>=parser()->context.token->indent)
5839 // new item at the same or lower indent level
5840 {
5841 retval = Token::make_TK_LISTITEM();
5842 goto endparagraph;
5843 }
5844 }
5845
5846 // determine list depth
5847 int depth = 0;
5848 n=parent();
5849 while (n)
5850 {
5851 al = std::get_if<DocAutoList>(n);
5852 if (al && al->isEnumList()) depth++;
5853 n=::parent(n);
5854 }
5855
5856 // first item or sub list => create new list
5857 do
5858 {
5859 children().append<DocAutoList>(parser(),thisVariant(),
5860 parser()->context.token->indent,
5861 parser()->context.token->isEnumList,depth,
5862 parser()->context.token->isCheckedList);
5863 al = children().get_last<DocAutoList>();
5864 retval = children().get_last<DocAutoList>()->parse();
5865 } while (retval.is(TokenRetval::TK_LISTITEM) && // new list
5866 al->indent()==parser()->context.token->indent // at same indent level
5867 );
5868
5869 // check the return value
5870 if (retval.is(TokenRetval::RetVal_SimpleSec)) // auto list ended due to simple section command
5871 {
5872 // Reparse the token that ended the section at this level,
5873 // so a new simple section will be started at this level.
5874 // This is the same as unputting the last read token and continuing.
5875 parser()->context.token->name = parser()->context.token->simpleSectName;
5876 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5877 {
5878 parser()->context.token->name = parser()->context.token->name.mid(4);
5879 parser()->context.token->text = parser()->context.token->simpleSectText;
5880 tok = Token::make_TK_RCSTAG();
5881 }
5882 else // other section
5883 {
5884 tok = Token::make_TK_COMMAND_BS();
5885 }
5886 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5887 goto reparsetoken;
5888 }
5889 else if (retval.is(TokenRetval::TK_ENDLIST))
5890 {
5891 if (al->indent()>parser()->context.token->indent) // end list
5892 {
5893 goto endparagraph;
5894 }
5895 else // continue with current paragraph
5896 {
5897 }
5898 }
5899 else // paragraph ended due to TokenRetval::TK_NEWPARA, TokenRetval::TK_LISTITEM, or EOF
5900 {
5901 goto endparagraph;
5902 }
5903 }
5904 break;
5905 case TokenRetval::TK_ENDLIST:
5906 AUTO_TRACE_ADD("Found end of list inside of paragraph at line {}",parser()->tokenizer.getLineNr());
5907 if (std::get_if<DocAutoListItem>(parent()))
5908 {
5909 const DocAutoList *al = std::get_if<DocAutoList>(::parent(parent()));
5910 if (al && al->indent()>=parser()->context.token->indent)
5911 {
5912 // end of list marker ends this paragraph
5913 retval = Token::make_TK_ENDLIST();
5914 goto endparagraph;
5915 }
5916 else
5917 {
5918 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found "
5919 "has invalid indent level");
5920 }
5921 }
5922 else
5923 {
5924 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found without any preceding "
5925 "list items");
5926 }
5927 break;
5928 case TokenRetval::TK_COMMAND_AT:
5929 // fall through
5930 case TokenRetval::TK_COMMAND_BS:
5931 {
5932 // see if we have to start a simple section
5933 CommandType cmd = Mappers::cmdMapper->map(parser()->context.token->name);
5934 const DocNodeVariant *n=parent();
5935 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5936 !std::holds_alternative<DocParamSect>(*n))
5937 {
5938 n=::parent(n);
5939 }
5940 if (cmd>CommandType::SIMPLESECT_BIT)
5941 {
5942 if (n) // already in a simple section
5943 {
5944 // simple section cannot start in this paragraph, need
5945 // to unwind the stack and remember the command.
5946 parser()->context.token->simpleSectName = parser()->context.token->name;
5947 retval = Token::make_RetVal_SimpleSec();
5948 goto endparagraph;
5949 }
5950 }
5951 // see if we are in a simple list
5952 n=parent();
5953 while (n && !std::holds_alternative<DocSimpleListItem>(*n)) n=::parent(n);
5954 if (n)
5955 {
5956 if (cmd==CommandType::CMD_LI)
5957 {
5958 retval = Token::make_RetVal_ListItem();
5959 goto endparagraph;
5960 }
5961 }
5962
5963 // handle the command
5964 retval=handleCommand(tok.command_to_char(),parser()->context.token->name);
5965 AUTO_TRACE_ADD("handleCommand returns {}",retval.to_string());
5966
5967 // check the return value
5968 if (retval.is(TokenRetval::RetVal_SimpleSec))
5969 {
5970 // Reparse the token that ended the section at this level,
5971 // so a new simple section will be started at this level.
5972 // This is the same as unputting the last read token and continuing.
5973 parser()->context.token->name = parser()->context.token->simpleSectName;
5974 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5975 {
5976 parser()->context.token->name = parser()->context.token->name.mid(4);
5977 parser()->context.token->text = parser()->context.token->simpleSectText;
5978 tok = Token::make_TK_RCSTAG();
5979 }
5980 else // other section
5981 {
5982 tok = Token::make_TK_COMMAND_BS();
5983 }
5984 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5985 goto reparsetoken;
5986 }
5987 else if (retval.value()>TokenRetval::TK_NONE && retval.value()<TokenRetval::RetVal_OK)
5988 {
5989 // the command ended with a new command, reparse this token
5990 tok = retval;
5991 goto reparsetoken;
5992 }
5993 else if (retval.value()!=TokenRetval::RetVal_OK) // end of file, end of paragraph, start or end of section
5994 // or some auto list marker
5995 {
5996 goto endparagraph;
5997 }
5998 }
5999 break;
6000 case TokenRetval::TK_HTMLTAG:
6001 {
6002 if (!parser()->context.token->endTag) // found a start tag
6003 {
6004 retval = handleHtmlStartTag(parser()->context.token->name,parser()->context.token->attribs);
6005 }
6006 else // found an end tag
6007 {
6008 if (checkIfHtmlEndTagEndsAutoList(parser(),parent()))
6009 {
6010 break; // new code has been pushed back to the scanner, need to reparse
6011 }
6012 retval = handleHtmlEndTag(parser()->context.token->name);
6013 }
6014 if (!retval.is(TokenRetval::RetVal_OK))
6015 {
6016 goto endparagraph;
6017 }
6018 }
6019 break;
6020 case TokenRetval::TK_SYMBOL:
6021 {
6022 HtmlEntityMapper::SymType s = DocSymbol::decodeSymbol(parser()->context.token->name);
6023 if (s!=HtmlEntityMapper::Sym_Unknown)
6024 {
6025 children().append<DocSymbol>(parser(),thisVariant(),s);
6026 }
6027 else
6028 {
6029 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
6030 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported symbol '{}' found",
6031 parser()->context.token->name);
6032 }
6033 break;
6034 }
6035 case TokenRetval::TK_NEWPARA:
6036 retval = Token::make_TK_NEWPARA();
6037 goto endparagraph;
6038 case TokenRetval::TK_RCSTAG:
6039 {
6040 const DocNodeVariant *n=parent();
6041 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
6042 !std::holds_alternative<DocParamSect>(*n))
6043 {
6044 n=::parent(n);
6045 }
6046 if (n) // already in a simple section
6047 {
6048 // simple section cannot start in this paragraph, need
6049 // to unwind the stack and remember the command.
6050 parser()->context.token->simpleSectName = "rcs:"+parser()->context.token->name;
6051 parser()->context.token->simpleSectText = parser()->context.token->text;
6052 retval = Token::make_RetVal_SimpleSec();
6053 goto endparagraph;
6054 }
6055
6056 // see if we are in a simple list
6057 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::Rcs);
6058 children().get_last<DocSimpleSect>()->parseRcs();
6059 }
6060 break;
6061 default:
6062 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
6063 "Found unexpected token (id={})",tok.to_string());
6064 break;
6065 }
6066 tok=parser()->tokenizer.lex();
6067 }
6068 retval=Token::make_TK_NONE();
6069endparagraph:
6070 parser()->handlePendingStyleCommands(thisVariant(),children());
6071 DocPara *par = std::get_if<DocPara>(parser()->context.nodeStack.top());
6072 if (!parser()->context.token->endTag && par &&
6073 retval.is(TokenRetval::TK_NEWPARA) && parser()->context.token->name.lower() == "p")
6074 {
6075 par->setAttribs(parser()->context.token->attribs);
6076 }
6077 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::TK_NEWPARA,TokenRetval::TK_LISTITEM,
6078 TokenRetval::TK_ENDLIST,TokenRetval::RetVal_OK)
6079 );
6080
6081 AUTO_TRACE_EXIT("retval={}",retval.to_string());
6082 return retval;
6083}
DocAutoList::isEnumList
bool isEnumList() const
Definition docnode.h:580
DocAutoList::indent
int indent() const
Definition docnode.h:581
DocPara::DocPara
DocPara(DocParser *parser, DocNodeVariant *parent)
Definition docnode.cpp:3578
DocPara::handleCommand
Token handleCommand(char cmdChar, const DString &cmdName)
Definition docnode.cpp:4229
DocPara::handleHtmlEndTag
Token handleHtmlEndTag(const DString &tagName)
Definition docnode.cpp:5509
DocPara::handleHtmlStartTag
Token handleHtmlStartTag(const DString &tagName, const HtmlAttribList &tagHtmlAttribs)
Definition docnode.cpp:5039
DocPara::setAttribs
void setAttribs(const HtmlAttribList &attribs)
Definition docnode.h:1120
DocParser::handlePendingStyleCommands
void handlePendingStyleCommands(DocNodeVariant *parent, DocNodeList &children, size_t numberOfElementsToClose=0)
Definition docparser.cpp:768
DocParser::handleInitialStyleCommands
void handleInitialStyleCommands(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:788
DocSymbol::decodeSymbol
static HtmlEntityMapper::SymType decodeSymbol(const DString &symName)
Definition docnode.cpp:168
Token::value
TokenRetval value() const
Definition doctokenizer.h:84
Token::command_to_char
char command_to_char() const
Definition doctokenizer.h:103
TokenInfo::simpleSectName
DString simpleSectName
Definition doctokenizer.h:152
TokenInfo::isEnumList
bool isEnumList
Definition doctokenizer.h:144
TokenInfo::chars
DString chars
Definition doctokenizer.h:168
TokenInfo::simpleSectText
DString simpleSectText
Definition doctokenizer.h:153
TokenInfo::isCheckedList
bool isCheckedList
Definition doctokenizer.h:145
TokenInfo::isEMailAddr
bool isEMailAddr
Definition doctokenizer.h:171
TokenInfo::text
DString text
Definition doctokenizer.h:139
AUTO_TRACE_ADD
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:54
checkIfHtmlEndTagEndsAutoList
static bool checkIfHtmlEndTagEndsAutoList(DocParser *parser, const DocNodeVariant *n)
Definition docnode.cpp:5730
holds_one_of_alternatives
constexpr bool holds_one_of_alternatives(const DocNodeVariant &v)
returns true iff v holds one of types passed as template parameters
Definition docnode.h:1371
insidePRE
bool insidePRE(const DocNodeVariant *n)
Definition docparser_p.h:193

References DocNodeList::append(), AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, TokenInfo::chars, checkIfHtmlEndTagEndsAutoList(), DocCompoundNode::children(), CMD_LI, Mappers::cmdMapper, Token::command_to_char(), DocParser::context, DocSymbol::decodeSymbol(), DocPara(), empty(), DocNodeList::get_last(), handleCommand(), handleHtmlEndTag(), handleHtmlStartTag(), DocParser::handleInitialStyleCommands(), DocParser::handleLinkedWord(), DocParser::handlePendingStyleCommands(), holds_one_of_alternatives(), DocAutoList::indent(), TokenInfo::indent, insidePRE(), INTERNAL_ASSERT, Token::is(), Token::is_any_of(), TokenInfo::isCheckedList, TokenInfo::isEMailAddr, DocAutoList::isEnumList(), TokenInfo::isEnumList, DocTokenizer::lex(), DString::mid(), TokenInfo::name, DocNode::parent(), parse(), DocNode::parser(), DocSimpleSect::Rcs, setAttribs(), SIMPLESECT_BIT, TokenInfo::simpleSectName, TokenInfo::simpleSectText, HtmlEntityMapper::Sym_Unknown, TokenInfo::text, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Token::value(), and warn_doc_error.

Referenced by handleCommand(), handleHtmlHeader(), handleHtmlStartTag(), handleInclude(), handleVhdlFlow(), DocHtmlBlockQuote::parse(), DocHtmlCell::parse(), DocHtmlDescData::parse(), DocHtmlDetails::parse(), DocHtmlListItem::parse(), parse(), DocParamList::parse(), DocParBlock::parse(), DocSimpleListItem::parse(), DocHtmlCell::parseXml(), and DocHtmlListItem::parseXml().

◆ setAttribs()

void DocPara::setAttribs ( const HtmlAttribList & attribs)
inline

Definition at line 1120 of file docnode.h.

1120{ m_attribs = attribs; }
DocPara::attribs
const HtmlAttribList & attribs() const
Definition docnode.h:1119

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1125 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1123 of file docnode.h.

Referenced by DocPara(), isFirst(), and markFirst().

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1124 of file docnode.h.

Referenced by DocPara(), isLast(), and markLast().

The documentation for this class was generated from the following files: