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

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 isEmpty () const
void markFirst (bool v=TRUE)
void markLast (bool v=TRUE)
bool isFirst () const
bool isLast () const
Token handleCommand (char cmdChar, const QCString &cmdName)
Token handleHtmlStartTag (const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Token handleHtmlEndTag (const QCString &tagName)
Token handleSimpleSection (DocSimpleSect::Type t, bool xmlContext=FALSE)
Token handleXRefItem ()
Token handleParamSection (const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
void handleIncludeOperator (const QCString &cmdName, DocIncOperator::Type t)
template<class T>
void handleFile (const QCString &cmdName)
void handleInclude (const QCString &cmdName, DocInclude::Type t)
void handleLink (const QCString &cmdName, bool isJavaLink)
void handleCite (char cmdChar, const QCString &cmdName)
void handleDoxyConfig (char cmdChar, const QCString &cmdName)
void handleEmoji (char cmdChar, const QCString &cmdName)
void handleRef (char cmdChar, const QCString &cmdName)
void handleSection (char cmdChar, const QCString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void handleILine (char cmdChar, const QCString &cmdName)
void handleIFile (char cmdChar, const QCString &cmdName)
void handleShowDate (char cmdChar, const QCString &cmdName)
Token handleStartCode ()
Token handleHtmlHeader (const HtmlAttribList &tagHtmlAttribs, int level)
bool injectToken (Token tok, const QCString &tokText)
const HtmlAttribListattribs () const
void setAttribs (const HtmlAttribList &attribs)
Public Member Functions inherited from DocCompoundNode
 DocCompoundNode (DocParser *parser, DocNodeVariant *parent)
DocNodeListchildren ()
const DocNodeListchildren () const
Public Member Functions inherited from DocNode
 DocNode (DocParser *parser, DocNodeVariant *parent)
 ~DocNode ()=default
DocNodeVariantparent ()
const DocNodeVariantparent () const
DocNodeVariantthisVariant ()
const DocNodeVariantthisVariant () const
void setThisVariant (DocNodeVariant *thisVariant)
DocParserparser ()
const DocParserparser () 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 }
Protected Member Functions inherited from DocNode
void setInsidePreformatted (bool p)

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1079 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3395 of file docnode.cpp.

3395 :
3398{
3399}
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:141
DocParser * parser()
Definition docnode.h:98
DocNodeVariant * parent()
Definition docnode.h:90
bool m_isFirst
Definition docnode.h:1118
bool m_isLast
Definition docnode.h:1119
#define FALSE
Definition qcstring.h:34

References DocCompoundNode::DocCompoundNode(), FALSE, 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 1114 of file docnode.h.

1114{ return m_attribs; }
HtmlAttribList m_attribs
Definition docnode.h:1120

References m_attribs.

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

◆ handleCite()

void DocPara::handleCite ( char cmdChar,
const QCString & cmdName )

Definition at line 3454 of file docnode.cpp.

3455{
3456 AUTO_TRACE();
3457 QCString saveCmdName = cmdName;
3458 // get the argument of the cite command.
3459 Token tok=parser()->tokenizer.lex();
3460
3461 CiteInfoOption option;
3462 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3463 {
3465 parser()->tokenizer.lex();
3466 StringVector optList=split(parser()->context.token->name.str(),",");
3467 for (auto const &opt : optList)
3468 {
3469 if (opt == "number")
3470 {
3471 if (!option.isUnknown())
3472 {
3473 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3474 }
3475 else
3476 {
3477 option = CiteInfoOption::makeNumber();
3478 }
3479 }
3480 else if (opt == "year")
3481 {
3482 if (!option.isUnknown())
3483 {
3484 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3485 }
3486 else
3487 {
3488 option = CiteInfoOption::makeYear();
3489 }
3490 }
3491 else if (opt == "shortauthor")
3492 {
3493 if (!option.isUnknown())
3494 {
3495 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3496 }
3497 else
3498 {
3500 }
3501 }
3502 else if (opt == "nopar")
3503 {
3504 option.setNoPar();
3505 }
3506 else if (opt == "nocite")
3507 {
3508 option.setNoCite();
3509 }
3510 else
3511 {
3512 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unknown option specified with \\{}, discarding '{}'", saveCmdName, opt);
3513 }
3514 }
3515
3516 if (option.isUnknown()) option.changeToNumber();
3517
3519 tok=parser()->tokenizer.lex();
3520 if (!tok.is(TokenRetval::TK_WHITESPACE))
3521 {
3522 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3523 saveCmdName);
3524 return;
3525 }
3526 }
3527 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3528 {
3529 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3530 cmdChar,saveCmdName);
3531 return;
3532 }
3533 else
3534 {
3535 option = CiteInfoOption::makeNumber();
3536 }
3537
3539 tok=parser()->tokenizer.lex();
3540 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3541 {
3542 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"THE ONE unexpected end of comment block while parsing the "
3543 "argument of command '{:c}{}'",cmdChar,saveCmdName);
3544 return;
3545 }
3546 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3547 {
3548 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3549 tok.to_string(),cmdChar,saveCmdName);
3550 return;
3551 }
3553 children().append<DocCite>(
3555
3557}
static CiteInfoOption makeYear()
Definition cite.h:31
static CiteInfoOption makeNumber()
Definition cite.h:29
void setNoCite()
Definition cite.h:35
bool isUnknown() const
Definition cite.h:37
void changeToNumber()
Definition cite.h:33
static CiteInfoOption makeShortAuthor()
Definition cite.h:30
void setNoPar()
Definition cite.h:34
DocNodeList & children()
Definition docnode.h:143
DocNodeVariant * thisVariant()
Definition docnode.h:93
DocTokenizer tokenizer
DocParserContext context
void setStateCite()
void setStateOptions()
void setStatePara()
bool is(TokenRetval rv) const
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
bool is_any_of(ARGS... args) const
std::vector< std::string > StringVector
Definition containers.h:33
#define AUTO_TRACE(...)
Definition docnode.cpp:46
#define warn(file, line, fmt,...)
Definition message.h:97
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
void append(Args &&... args)
Append a new DocNodeVariant to the list by constructing it with type T and parameters Args.
Definition docnode.h:1399
TokenInfo * token
Definition docparser_p.h:93
QCString sectionId
QCString name
StringVector split(const std::string &s, const std::string &delimiter)
split input string s by string delimiter delimiter.
Definition util.cpp:7135

References DocNodeList::append(), AUTO_TRACE, CiteInfoOption::changeToNumber(), DocCompoundNode::children(), DocParser::context, DocParserContext::context, Token::is(), Token::is_any_of(), CiteInfoOption::isUnknown(), DocTokenizer::lex(), CiteInfoOption::makeNumber(), CiteInfoOption::makeShortAuthor(), CiteInfoOption::makeYear(), TokenInfo::name, DocNode::parser(), TokenInfo::sectionId, CiteInfoOption::setNoCite(), CiteInfoOption::setNoPar(), DocTokenizer::setStateCite(), DocTokenizer::setStateOptions(), DocTokenizer::setStatePara(), split(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleCommand()

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

Definition at line 4211 of file docnode.cpp.

4212{
4213 AUTO_TRACE("cmdName={}",cmdName);
4214 Token retval = Token::make_RetVal_OK();
4215 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
4216 switch (cmdId)
4217 {
4219 {
4220 std::string str{cmdChar};
4221 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
4222 if (isAliasCmd(cmdName.view()))
4223 {
4224 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
4225 }
4226 else
4227 {
4228 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4229 }
4230 }
4231 break;
4233 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,TRUE);
4234 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4235 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,FALSE);
4236 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4237 break;
4239 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,TRUE);
4240 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4241 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,FALSE);
4242 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4243 break;
4245 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,TRUE);
4246 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4247 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,FALSE);
4248 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4249 break;
4252 break;
4255 break;
4258 break;
4261 break;
4264 break;
4267 break;
4270 break;
4273 break;
4276 break;
4279 break;
4283 break;
4288 break;
4291 break;
4294 break;
4297 break;
4300 break;
4303 break;
4306 break;
4309 break;
4314 break;
4318 break;
4321 break;
4324 break;
4327 break;
4330 break;
4333 break;
4336 break;
4339 break;
4342 break;
4345 break;
4348 break;
4351 break;
4354 break;
4357 break;
4360 break;
4363 break;
4365 {
4366 children().append<DocSimpleList>(parser(),thisVariant());
4367 retval = children().get_last<DocSimpleList>()->parse();
4368 }
4369 break;
4371 {
4372 handleSection(cmdChar,cmdName);
4373 retval = Token::make_RetVal_Section();
4374 }
4375 break;
4377 {
4378 handleSection(cmdChar,cmdName);
4379 retval = Token::make_RetVal_Subsection();
4380 }
4381 break;
4383 {
4384 handleSection(cmdChar,cmdName);
4385 retval = Token::make_RetVal_Subsubsection();
4386 }
4387 break;
4389 {
4390 handleSection(cmdChar,cmdName);
4391 retval = Token::make_RetVal_Paragraph();
4392 }
4393 break;
4395 {
4396 handleSection(cmdChar,cmdName);
4397 retval = Token::make_RetVal_SubParagraph();
4398 }
4399 break;
4401 {
4402 handleSection(cmdChar,cmdName);
4403 retval = Token::make_RetVal_SubSubParagraph();
4404 }
4405 break;
4407 {
4409 retval = handleStartCode();
4410 }
4411 break;
4413 {
4415 retval = handleStartCode();
4416 }
4417 break;
4419 {
4421 retval = parser()->tokenizer.lex();
4423 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4424 {
4425 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4426 }
4428 }
4429 break;
4431 {
4433 retval = parser()->tokenizer.lex();
4435 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4436 {
4437 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4438 }
4440 }
4441 break;
4443 {
4445 retval = parser()->tokenizer.lex();
4447 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4448 {
4449 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4450 }
4452 }
4453 break;
4455 {
4457 retval = parser()->tokenizer.lex();
4459 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4460 {
4461 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4462 }
4464 }
4465 break;
4467 {
4469 retval = parser()->tokenizer.lex();
4471 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4472 {
4473 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4474 }
4476 }
4477 break;
4479 {
4481 retval = parser()->tokenizer.lex();
4483 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4484 {
4485 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4486 }
4488 }
4489 break;
4491 {
4494 parser()->tokenizer.lex();
4495
4496 QCString fullMatch = parser()->context.token->verb;
4497 int idx = fullMatch.find('{');
4498 int idxEnd = fullMatch.find("}",idx+1);
4499 StringVector optList;
4500 if (idx != -1) // options present
4501 {
4502 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4503 optList = split(optStr.str(),",");
4504 for (const auto &opt : optList)
4505 {
4506 if (opt.empty()) continue;
4507 QCString locOpt(opt);
4508 locOpt = locOpt.stripWhiteSpace().lower();
4509 if (locOpt == "code")
4510 {
4512 }
4513 else if (!locOpt.isEmpty())
4514 {
4515 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4516 }
4517 }
4518 }
4519
4521 retval = parser()->tokenizer.lex();
4523 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4524 {
4525 if (t == DocVerbatim::JavaDocCode)
4526 {
4527 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4528 }
4529 else
4530 {
4531 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4532 }
4533 }
4535 }
4536 break;
4539 {
4540 if (cmdId == CommandType::CMD_VERBATIM)
4541 {
4543 }
4544 else
4545 {
4547 }
4548 retval = parser()->tokenizer.lex();
4550 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4551 {
4552 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4553 }
4555 }
4556 break;
4558 {
4559 children().append<DocVerbatim>(parser(),thisVariant(),
4565 DocVerbatim *dv = children().get_last<DocVerbatim>();
4567 QCString width,height;
4568 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4570 retval = parser()->tokenizer.lex();
4571 dv->setText(parser()->context.token->verb);
4572 dv->setWidth(width);
4573 dv->setHeight(height);
4574 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4575 if (!Config_getBool(HAVE_DOT))
4576 {
4577 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4578 children().pop_back();
4579 }
4580 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4581 {
4582 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4583 }
4585 }
4586 break;
4588 {
4589 children().append<DocVerbatim>(parser(),thisVariant(),
4595 DocVerbatim *dv = children().get_last<DocVerbatim>();
4597 QCString width,height;
4598 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4600 retval = parser()->tokenizer.lex();
4601 dv->setText(parser()->context.token->verb);
4602 dv->setWidth(width);
4603 dv->setHeight(height);
4604 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4605 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4606 {
4607 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4608 }
4610 }
4611 break;
4613 {
4614 QCString jarPath = Config_getString(PLANTUML_JAR_PATH);
4616 parser()->tokenizer.lex();
4617 QCString fullMatch = parser()->context.token->sectionId;
4618 QCString sectionId = "";
4619 int idx = fullMatch.find('{');
4620 int idxEnd = fullMatch.find("}",idx+1);
4621 StringVector optList;
4622 QCString engine;
4623 if (idx != -1) // options present
4624 {
4625 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4626 optList = split(optStr.str(),",");
4627 for (const auto &opt : optList)
4628 {
4629 if (opt.empty()) continue;
4630 bool found = false;
4631 QCString locOpt(opt);
4632 locOpt = locOpt.stripWhiteSpace().lower();
4633 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4634 {
4635 if (!engine.isEmpty())
4636 {
4637 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4638 }
4639 engine = locOpt;
4640 found = true;
4641 }
4642 if (!found)
4643 {
4644 if (sectionId.isEmpty())
4645 {
4646 sectionId = opt;
4647 }
4648 else
4649 {
4650 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4651 }
4652 }
4653 }
4654 }
4655 else
4656 {
4657 sectionId = parser()->context.token->sectionId;
4658 }
4659 if (engine.isEmpty()) engine = "uml";
4660
4661 if (sectionId.isEmpty())
4662 {
4664 retval = parser()->tokenizer.lex();
4665 assert(retval.is(TokenRetval::RetVal_OK));
4666
4667 sectionId = parser()->context.token->sectionId;
4668 sectionId = sectionId.stripWhiteSpace();
4669 }
4670
4671 QCString plantFile(sectionId);
4672 children().append<DocVerbatim>(parser(),thisVariant(),
4676 FALSE,plantFile);
4677 DocVerbatim *dv = children().get_last<DocVerbatim>();
4678 dv->setEngine(engine);
4680 QCString width,height;
4681 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4683 retval = parser()->tokenizer.lex();
4684 int line = 0;
4685 QCString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4686 if (engine == "ditaa")
4687 {
4688 dv->setUseBitmap(true);
4689 }
4690 else if (engine == "uml")
4691 {
4692 int i = trimmedVerb.find('\n');
4693 QCString firstLine = i==-1 ? trimmedVerb : trimmedVerb.left(i);
4694 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4695 }
4696 dv->setText(trimmedVerb);
4697 dv->setWidth(width);
4698 dv->setHeight(height);
4699 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4700 if (jarPath.isEmpty())
4701 {
4702 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because PLANTUML_JAR_PATH is not set");
4703 children().pop_back();
4704 }
4705 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4706 {
4707 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4708 }
4710 }
4711 break;
4713 retval = Token::make_RetVal_EndParBlock();
4714 break;
4730 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4731 break;
4733 retval = handleParamSection(cmdName,DocParamSect::Param,FALSE,parser()->context.token->paramDir);
4734 break;
4736 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,FALSE,parser()->context.token->paramDir);
4737 break;
4739 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4740 break;
4743 break;
4745 retval = handleXRefItem();
4746 break;
4748 {
4749 children().append<DocLineBreak>(parser(),thisVariant());
4750 }
4751 break;
4754 {
4756 }
4757 break;
4759 {
4761 }
4762 break;
4764 {
4765 children().append<DocIndexEntry>(parser(),thisVariant(),
4768 retval = children().get_last<DocIndexEntry>()->parse();
4769 }
4770 break;
4772 retval = Token::make_RetVal_Internal();
4773 break;
4775 retval = Token::make_RetVal_EndInternal();
4776 break;
4778 {
4779 children().append<DocParBlock>(parser(),thisVariant());
4780 retval = children().get_last<DocParBlock>()->parse();
4781 }
4782 break;
4783 case CommandType::CMD_COPYDOC: // fall through
4784 case CommandType::CMD_COPYBRIEF: // fall through
4786 //retval = Token::make_RetVal_CopyDoc();
4787 // these commands should already be resolved by processCopyDoc()
4788 break;
4791 break;
4794 break;
4797 break;
4800 break;
4803 break;
4806 break;
4809 break;
4812 break;
4815 break;
4818 break;
4821 break;
4824 break;
4827 break;
4830 break;
4833 break;
4836 break;
4839 break;
4841 if (!Config_getBool(HAVE_DOT))
4842 {
4843 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4844 "ignoring \\dotfile command because HAVE_DOT is not set");
4845 }
4846 else
4847 {
4848 handleFile<DocDotFile>(cmdName);
4849 }
4850 break;
4853 break;
4855 handleFile<DocMscFile>(cmdName);
4856 break;
4858 handleFile<DocDiaFile>(cmdName);
4859 break;
4862 break;
4864 handleLink(cmdName,FALSE);
4865 break;
4867 handleLink(cmdName,TRUE);
4868 break;
4870 handleCite(cmdChar,cmdName);
4871 break;
4873 handleEmoji(cmdChar,cmdName);
4874 break;
4876 handleDoxyConfig(cmdChar,cmdName);
4877 break;
4878 case CommandType::CMD_REF: // fall through
4880 handleRef(cmdChar,cmdName);
4881 break;
4883 {
4884 children().append<DocSecRefList>(parser(),thisVariant());
4885 children().get_last<DocSecRefList>()->parse();
4886 }
4887 break;
4889 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4890 break;
4892 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4893 break;
4895 {
4896 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4897 }
4898 break;
4899 //case CommandType::CMD_LANGSWITCH:
4900 // retval = handleLanguageSwitch();
4901 // break;
4903 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4904 {
4907 }
4908 break;
4911 break;
4913 handleShowDate(cmdChar,cmdName);
4914 break;
4916 handleILine(cmdChar,cmdName);
4917 break;
4919 handleIFile(cmdChar,cmdName);
4920 break;
4922 {
4924 (void)parser()->tokenizer.lex();
4926 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
4928 }
4929 break;
4930 default:
4931 // we should not get here!
4932 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
4933 break;
4934 }
4935 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
4936 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
4937 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
4938 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
4939 TokenRetval::RetVal_EndInternal)
4940 );
4941 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4942 return retval;
4943}
bool isAliasCmd(std::string_view aliasCmd)
Definition aliases.cpp:528
@ LatexInclude
Definition docnode.h:437
@ SnippetWithLines
Definition docnode.h:438
@ IncWithLines
Definition docnode.h:438
@ HtmlInclude
Definition docnode.h:437
@ VerbInclude
Definition docnode.h:437
@ DontInclude
Definition docnode.h:437
@ DocbookInclude
Definition docnode.h:439
Token handleSimpleSection(DocSimpleSect::Type t, bool xmlContext=FALSE)
Definition docnode.cpp:3401
void handleLink(const QCString &cmdName, bool isJavaLink)
Definition docnode.cpp:3916
void handleInheritDoc()
Definition docnode.cpp:4174
void handleCite(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3454
void handleInclude(const QCString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3984
void handleDoxyConfig(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3590
void handleSection(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4089
void handleFile(const QCString &cmdName)
Definition docnode.cpp:3877
void handleIFile(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3793
Token handleParamSection(const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3431
void handleEmoji(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3559
void handleIncludeOperator(const QCString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3817
void handleRef(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3957
void handleILine(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3779
Token parse()
Definition docnode.cpp:5707
void handleVhdlFlow()
Definition docnode.cpp:3909
void handleShowDate(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3709
Token handleXRefItem()
Definition docnode.cpp:3688
Token handleStartCode()
Definition docnode.cpp:4138
void handleInternalRef(DocNodeVariant *parent, DocNodeList &children)
void handleImage(DocNodeVariant *parent, DocNodeList &children)
void handlePrefix(DocNodeVariant *parent, DocNodeList &children)
Token handleStyleArgument(DocNodeVariant *parent, DocNodeList &children, const QCString &cmdName)
void handleAnchor(DocNodeVariant *parent, DocNodeList &children)
void defaultHandleTitleAndSize(const CommandType cmd, DocNodeVariant *parent, DocNodeList &children, QCString &width, QCString &height)
void setStateILiteralOpt()
void setStateILiteral()
void setStateCode()
void setStatePlantUMLOpt()
void setStateRtfOnly()
void setStateVerbatim()
void setStateLatexOnly()
void setStateManOnly()
void setStateDbOnly()
void setStateHtmlOnly()
void setStateICode()
void setStatePlantUML()
void setStateIVerbatim()
void setStateXmlOnly()
void setStateSetScope()
@ JavaDocLiteral
Definition docnode.h:378
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
void pop_back()
removes the last element
Definition growvector.h:115
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:241
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:260
const std::string & str() const
Definition qcstring.h:552
std::string_view view() const
Definition qcstring.h:174
QCString left(size_t len) const
Definition qcstring.h:229
CommandType
Definition cmdmapper.h:29
@ CMD_ENDSECREFLIST
Definition cmdmapper.h:53
@ CMD_ENDLATEXONLY
Definition cmdmapper.h:51
@ CMD_ENDVERBATIM
Definition cmdmapper.h:54
@ CMD_DONTINCLUDE
Definition cmdmapper.h:46
@ CMD_SUBSUBSECTION
Definition cmdmapper.h:89
@ CMD_SUBSUBPARAGRAPH
Definition cmdmapper.h:161
@ CMD_INTERNALREF
Definition cmdmapper.h:65
@ CMD_ENDHTMLONLY
Definition cmdmapper.h:50
@ CMD_VERBINCLUDE
Definition cmdmapper.h:98
@ CMD_DOCBOOKINCLUDE
Definition cmdmapper.h:145
@ CMD_HTMLINCLUDE
Definition cmdmapper.h:60
@ CMD_SNIPWITHLINES
Definition cmdmapper.h:141
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
static const StringUnorderedSet g_plantumlEngine
Definition docnode.cpp:69
#define INTERNAL_ASSERT(x)
Definition docnode.cpp:51
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:48
const Mapper< CommandType > * cmdMapper
#define TRUE
Definition qcstring.h:37
T * get_last()
Returns a pointer to the last element in the list if that element exists and holds a T,...
Definition docnode.h:1410
DocNodeStack nodeStack
Definition docparser_p.h:67
QCString exampleName
Definition docparser_p.h:80
const Definition * scope
Definition docparser_p.h:61
const MemberDef * memberDef
Definition docparser_p.h:78
QCString verb
QCString stripLeadingAndTrailingEmptyLines(const QCString &s, int &docLine)
Special version of QCString::stripWhiteSpace() that only strips completely blank lines.
Definition util.cpp:5543

References DocNodeList::append(), 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_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_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, Config_getString, DocParser::context, DocParserContext::context, DocSimpleSect::Copyright, DocSimpleSect::Date, DocParser::defaultHandleTitleAndSize(), DocInclude::DocbookInclude, DocVerbatim::DocbookOnly, DocInclude::DontInclude, DocVerbatim::Dot, DocParserContext::exampleName, DocParamSect::Exception, FALSE, QCString::find(), g_plantumlEngine, DocNodeList::get_last(), Doxygen::globalScope, DocParser::handleAnchor(), handleCite(), handleDoxyConfig(), handleEmoji(), handleFile(), handleIFile(), handleILine(), DocParser::handleImage(), handleInclude(), handleIncludeOperator(), handleInheritDoc(), DocParser::handleInternalRef(), handleLink(), handleParamSection(), DocParser::handlePrefix(), 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(), QCString::isEmpty(), DocParserContext::isExample, DocStyleChange::Italic, DocVerbatim::JavaDocCode, DocVerbatim::JavaDocLiteral, DocInclude::LatexInclude, DocVerbatim::LatexOnly, QCString::left(), DocTokenizer::lex(), DocIncOperator::Line, QCString::lower(), DocInclude::ManInclude, DocVerbatim::ManOnly, DocParserContext::memberDef, QCString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DocParamSect::Param, 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::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(), QCString::str(), stripLeadingAndTrailingEmptyLines(), QCString::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, TRUE, UNKNOWN, DocIncOperator::Until, DocSimpleSect::User, TokenInfo::verb, DocVerbatim::Verbatim, DocInclude::VerbInclude, DocSimpleSect::Version, QCString::view(), warn, warn_doc_error, DocSimpleSect::Warning, DocInclude::XmlInclude, and DocVerbatim::XmlOnly.

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3590 of file docnode.cpp.

3591{
3592 // get the argument of the cite command.
3593 Token tok=parser()->tokenizer.lex();
3594 if (!tok.is(TokenRetval::TK_WHITESPACE))
3595 {
3596 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3597 cmdChar,cmdName);
3598 return;
3599 }
3601 tok=parser()->tokenizer.lex();
3602 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3603 {
3604 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3605 "argument of command '{:c}{}'",cmdChar,cmdName);
3606 return;
3607 }
3608 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3609 {
3610 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3611 tok.to_string(),cmdChar,cmdName);
3612 return;
3613 }
3614 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3615 if (opt)
3616 {
3617 QCString optionValue;
3618 switch (opt->kind())
3619 {
3621 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3622 break;
3624 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3625 break;
3627 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3628 break;
3630 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3631 break;
3633 {
3634 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3635 optionValue="";
3636 if (!lst->empty())
3637 {
3638 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3639 static const reg::Ex marker(R"(@(\d+))");
3640 reg::Iterator it(lstFormat,marker);
3641 reg::Iterator end;
3642 size_t index=0;
3643 // now replace all markers with the real text
3644 for ( ; it!=end ; ++it)
3645 {
3646 const auto &match = *it;
3647 size_t newIndex = match.position();
3648 size_t matchLen = match.length();
3649 optionValue += lstFormat.substr(index,newIndex-index);
3650 unsigned long entryIndex = std::stoul(match[1].str());
3651 if (entryIndex<(unsigned long)lst->size())
3652 {
3653 optionValue += lst->at(entryIndex);
3654 }
3655 index=newIndex+matchLen;
3656 }
3657 optionValue+=lstFormat.substr(index);
3658 }
3659 }
3660 break;
3662 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3663 cmdChar,cmdName,parser()->context.token->name);
3664 break;
3666 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3667 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3668 cmdChar,cmdName,parser()->context.token->name);
3669 break;
3671 // nothing to show here
3672 break;
3673 }
3674 if (!optionValue.isEmpty())
3675 {
3676 children().append<DocWord>(parser(),thisVariant(),optionValue);
3677 }
3678 }
3679 else
3680 {
3681 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3682 cmdChar,cmdName,parser()->context.token->name);
3684 }
3686}
static ConfigImpl * instance()
Definition configimpl.h:351
ConfigOption * get(const QCString &name) const
Definition configimpl.h:400
@ O_Disabled
Disabled compile time option.
Definition configimpl.h:55
@ O_List
A list of items.
Definition configimpl.h:49
@ O_Enum
A fixed set of items.
Definition configimpl.h:50
@ O_Bool
A boolean value.
Definition configimpl.h:53
@ O_String
A single item.
Definition configimpl.h:51
@ O_Obsolete
An obsolete option.
Definition configimpl.h:54
@ O_Int
An integer value.
Definition configimpl.h:52
@ O_Info
A section header.
Definition configimpl.h:48
OptionType kind() const
Definition configimpl.h:70
void setStateDoxyConfig()
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:593
virtual QCString trWriteList(int numEntries)=0
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:175
Translator * theTranslator
Definition language.cpp:71
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:759

References DocNodeList::append(), DocCompoundNode::children(), DocParser::context, end(), ConfigImpl::get(), ConfigImpl::instance(), Token::is(), Token::is_any_of(), QCString::isEmpty(), 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(), theTranslator, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, ConfigEnum::valueRef(), ConfigString::valueRef(), ConfigBool::valueStringRef(), ConfigInt::valueStringRef(), warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleEmoji()

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

Definition at line 3559 of file docnode.cpp.

3560{
3561 AUTO_TRACE();
3562 // get the argument of the emoji command.
3563 Token tok=parser()->tokenizer.lex();
3564 if (!tok.is(TokenRetval::TK_WHITESPACE))
3565 {
3566 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3567 cmdChar,cmdName);
3568 return;
3569 }
3571 tok=parser()->tokenizer.lex();
3572 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3573 {
3574 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3575 "argument of command '{:c}{}'",cmdChar,cmdName);
3577 return;
3578 }
3579 else if (!tok.is(TokenRetval::TK_WORD))
3580 {
3581 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3582 tok.to_string(),cmdChar,cmdName);
3584 return;
3585 }
3588}
void setStateEmoji()

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 QCString & cmdName)

Definition at line 3877 of file docnode.cpp.

3878{
3879 AUTO_TRACE("cmdName={}",cmdName);
3880 QCString saveCmdName = cmdName;
3881 Token tok=parser()->tokenizer.lex();
3882 if (!tok.is(TokenRetval::TK_WHITESPACE))
3883 {
3884 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3885 saveCmdName);
3886 return;
3887 }
3889 tok=parser()->tokenizer.lex();
3891 if (!tok.is(TokenRetval::TK_WORD))
3892 {
3893 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3894 tok.to_string(),saveCmdName);
3895 return;
3896 }
3897 QCString name = parser()->context.token->name;
3898 children().append<T>(parser(),thisVariant(),name,
3902 auto df = children().get_last<T>();
3903 if (!df->parse())
3904 {
3905 children().pop_back();
3906 }
3907}
void setStateFile()
int getLineNr(void)
QCString fileName
Definition docparser_p.h:71

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 QCString & tagName)

Definition at line 5434 of file docnode.cpp.

5435{
5436 AUTO_TRACE("tagName={}",tagName);
5437 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5438 Token retval = Token::make_RetVal_OK();
5439 switch (tagId)
5440 {
5442 if (!insideUL(thisVariant()))
5443 {
5444 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5445 }
5446 else
5447 {
5448 retval = Token::make_RetVal_EndList();
5449 }
5450 break;
5452 if (!insideOL(thisVariant()))
5453 {
5454 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5455 }
5456 else
5457 {
5458 retval = Token::make_RetVal_EndList();
5459 }
5460 break;
5462 if (!insideLI(thisVariant()))
5463 {
5464 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5465 }
5466 else
5467 {
5468 // ignore </li> tags
5469 }
5470 break;
5472 if (!insideDetails(thisVariant()))
5473 {
5474 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5475 }
5476 else
5477 {
5478 retval = Token::make_RetVal_EndHtmlDetails();
5479 }
5480 break;
5483 {
5484 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5485 }
5486 else
5487 {
5488 retval = Token::make_RetVal_EndBlockQuote();
5489 }
5490 break;
5493 break;
5496 break;
5499 break;
5502 break;
5505 break;
5508 break;
5511 break;
5514 break;
5517 break;
5520 break;
5523 break;
5526 break;
5529 break;
5532 break;
5535 break;
5538 break;
5541 break;
5546 break;
5548 retval = Token::make_TK_NEWPARA();
5549 break;
5551 retval = Token::make_RetVal_EndDesc();
5552 break;
5554 // ignore </dt> tag
5555 break;
5557 // ignore </dd> tag
5558 break;
5560 retval = Token::make_RetVal_EndTable();
5561 break;
5563 retval = Token::make_RetVal_EndTableRow();
5564 break;
5566 retval = Token::make_RetVal_EndTableCell();
5567 break;
5569 retval = Token::make_RetVal_EndTableCell();
5570 break;
5574 // for time being ignore </t....> tag
5575 break;
5577 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5578 break;
5580 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5581 break;
5583 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5584 break;
5586 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5587 break;
5589 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5590 break;
5592 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5593 break;
5595 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5596 break;
5598 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5599 break;
5601 break;
5603 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5604 break;
5606 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5607 // ignore </a> tag (can be part of <a name=...></a>
5608 break;
5609
5611 break;
5613 retval = Token::make_TK_NEWPARA();
5614 break;
5627 retval = Token::make_RetVal_CloseXml();
5628 break;
5629 case HtmlTagType::XML_C:
5631 break;
5639 // These tags are defined in .Net but are currently unsupported
5640 break;
5642 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5643 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5644 break;
5645 default:
5646 // we should not get here!
5647 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5648 ASSERT(0);
5649 break;
5650 }
5651 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5652 return retval;
5653}
void setInsidePreformatted(bool p)
Definition docnode.h:109
void handleStyleLeave(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const QCString &tagName)
void setInsidePre(bool b)
HtmlTagType
Definition cmdmapper.h:169
bool insideUL(const DocNodeVariant *n)
bool insideLI(const DocNodeVariant *n)
bool insideBlockQuote(const DocNodeVariant *n)
bool insideDetails(const DocNodeVariant *n)
bool insideOL(const DocNodeVariant *n)
const Mapper< HtmlTagType > * htmlTagMapper
#define ASSERT(x)
Definition qcstring.h:39

References DocNodeList::append(), ASSERT, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, DocStyleChange::Del, DocStyleChange::Div, FALSE, 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 4120 of file docnode.cpp.

4121{
4122 AUTO_TRACE();
4123 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4124 Token retval = children().get_last<DocHtmlHeader>()->parse();
4125 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4126}

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

Referenced by handleHtmlStartTag().

◆ handleHtmlStartTag()

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

Definition at line 4961 of file docnode.cpp.

4962{
4963 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4964 Token retval = Token::make_RetVal_OK();
4965 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4966 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4969 {
4970 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4971 tagName);
4972 }
4973 switch (tagId)
4974 {
4976 if (!parser()->context.token->emptyTag)
4977 {
4978 children().append<DocHtmlList>(parser(),thisVariant(),
4979 tagHtmlAttribs,DocHtmlList::Unordered);
4980 retval=children().get_last<DocHtmlList>()->parse();
4981 }
4982 break;
4984 if (!parser()->context.token->emptyTag)
4985 {
4986 children().append<DocHtmlList>(parser(),thisVariant(),
4987 tagHtmlAttribs,DocHtmlList::Ordered);
4988 retval=children().get_last<DocHtmlList>()->parse();
4989 }
4990 break;
4992 if (parser()->context.token->emptyTag) break;
4994 {
4995 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
4996 }
4997 else
4998 {
4999 retval = Token::make_RetVal_ListItem();
5000 }
5001 break;
5003 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
5004 break;
5006 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
5007 break;
5009 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
5010 break;
5012 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
5013 break;
5015 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
5016 break;
5018 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
5019 break;
5021 if (parser()->context.token->emptyTag) break;
5022 if (parser()->context.xmlComment)
5023 // for C# source or inside a <summary> or <remark> section we
5024 // treat <code> as an XML tag (so similar to @code)
5025 {
5027 retval = handleStartCode();
5028 }
5029 else // normal HTML markup
5030 {
5031 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5032 }
5033 break;
5035 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
5036 break;
5038 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
5039 break;
5041 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
5042 break;
5044 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
5045 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5046 break;
5048 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5049 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5050 break;
5052 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5053 break;
5055 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5056 break;
5058 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5059 break;
5061 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5062 break;
5064 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5065 break;
5067 if (parser()->context.token->emptyTag) break;
5068 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5071 break;
5073 retval = Token::make_TK_NEWPARA();
5074 break;
5076 if (!parser()->context.token->emptyTag)
5077 {
5078 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5079 retval=children().get_last<DocHtmlDescList>()->parse();
5080 }
5081 break;
5083 if (insideDL(thisVariant()))
5084 {
5085 retval = Token::make_RetVal_DescTitle();
5086 }
5087 else
5088 {
5089 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5090 }
5091 break;
5093 if (insideDL(thisVariant()))
5094 {
5095 retval = Token::make_RetVal_DescData();
5096 }
5097 else
5098 {
5099 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5100 }
5101 break;
5103 if (!parser()->context.token->emptyTag)
5104 {
5105 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5106 retval=children().get_last<DocHtmlTable>()->parse();
5107 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5108 }
5109 break;
5111 retval = Token::make_RetVal_TableRow();
5112 break;
5114 retval = Token::make_RetVal_TableCell();
5115 break;
5117 retval = Token::make_RetVal_TableHCell();
5118 break;
5122 // for time being ignore </t....> tag
5123 break;
5125 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5126 break;
5128 {
5129 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5130 }
5131 break;
5133 {
5134 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5135 }
5136 break;
5138 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5139 break;
5141 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5142 break;
5144 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5145 break;
5147 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5148 break;
5150 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5151 break;
5153 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5154 break;
5156 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5157 break;
5159 {
5160 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5161 }
5162 break;
5164 if (!parser()->context.token->emptyTag)
5165 {
5166 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5167 retval=children().get_last<DocHtmlDetails>()->parse();
5168 }
5169 break;
5171 if (!parser()->context.token->emptyTag)
5172 {
5173 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5174 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5175 }
5176 break;
5177
5180 {
5181 if (!parser()->context.token->emptyTag)
5182 {
5184 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5185 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5186 if (d)
5187 {
5188 if (!d->summary()) // details section does not have a summary yet
5189 {
5190 d->parseSummary(n,parser()->context.token->attribs);
5191 }
5192 else
5193 {
5194 retval = Token::make_TK_NEWPARA();
5195 }
5196 }
5197 }
5198 }
5199 break;
5203 // fall through
5206 if (!children().empty())
5207 {
5208 retval = Token::make_TK_NEWPARA();
5209 }
5210 break;
5212 if (insideTable(thisVariant()))
5213 {
5214 retval = Token::make_RetVal_TableCell();
5215 }
5216 break;
5217 case HtmlTagType::XML_C:
5218 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5219 break;
5222 {
5224 QCString paramName;
5225 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5226 {
5227 if (paramName.isEmpty())
5228 {
5229 if (Config_getBool(WARN_NO_PARAMDOC))
5230 {
5231 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5232 }
5233 }
5234 else
5235 {
5236 retval = handleParamSection(paramName,
5238 TRUE);
5239 }
5240 }
5241 else
5242 {
5243 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5244 }
5245 }
5246 break;
5249 {
5250 QCString paramName;
5251 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5252 {
5253 //printf("paramName=%s\n",qPrint(paramName));
5254 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5255 children().append<DocWord>(parser(),thisVariant(),paramName);
5256 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5257 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5258 }
5259 else
5260 {
5261 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5262 }
5263 }
5264 break;
5266 {
5268 QCString exceptName;
5269 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5270 {
5271 unescapeCRef(exceptName);
5272 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5273 }
5274 else
5275 {
5276 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5277 }
5278 }
5279 break;
5282 if (insideTable(thisVariant()))
5283 {
5284 retval = Token::make_RetVal_TableRow();
5285 }
5286 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5287 {
5288 retval = Token::make_RetVal_ListItem();
5289 }
5290 else
5291 {
5292 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5293 }
5294 break;
5299 break;
5301 if (insideTable(thisVariant()))
5302 {
5303 retval = Token::make_RetVal_TableCell();
5304 }
5305 break;
5307 // I'm not sure if <see> is the same as <seealso> or if it
5308 // should you link a member without producing a section. The
5309 // C# specification is extremely vague about this (but what else
5310 // can we expect from Microsoft...)
5311 {
5312 QCString cref;
5313 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5314 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5315 {
5316 unescapeCRef(cref);
5317 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5318 {
5319 bool inSeeBlock = parser()->context.inSeeBlock;
5320 parser()->context.token->name = cref;
5323 parser()->context.inSeeBlock = inSeeBlock;
5324 }
5325 else // <see cref="...">...</see> style
5326 {
5327 //DocRef *ref = new DocRef(this,cref);
5328 //children().append(ref);
5329 //ref->parse();
5331 children().append<DocLink>(parser(),thisVariant(),cref);
5332 DocLink *lnk = children().get_last<DocLink>();
5333 QCString leftOver = lnk->parse(FALSE,TRUE);
5334 if (!leftOver.isEmpty())
5335 {
5336 children().append<DocWord>(parser(),thisVariant(),leftOver);
5337 }
5338 }
5339 }
5340 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5341 {
5342 bool inSeeBlock = parser()->context.inSeeBlock;
5343 parser()->context.token->name = cref;
5345 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5347 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5348 parser()->context.inSeeBlock = inSeeBlock;
5349 }
5350 else
5351 {
5352 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5353 }
5354 }
5355 break;
5357 {
5359 QCString cref;
5360 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5361 {
5362 unescapeCRef(cref);
5363 // Look for an existing "see" section
5364 DocNodeVariant *vss=nullptr;
5365 for (auto &n : children())
5366 {
5367 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5368 if (candidate && candidate->type()==DocSimpleSect::See)
5369 {
5370 vss = &n;
5371 }
5372 }
5373
5374 if (!vss) // start new section
5375 {
5376 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5377 vss = &children().back();
5378 }
5379
5380 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5381 retval = Token::make_RetVal_OK();
5382 }
5383 else
5384 {
5385 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5386 }
5387 }
5388 break;
5390 {
5391 QCString type;
5392 findAttribute(tagHtmlAttribs,"type",&type);
5394 HtmlAttribList emptyList;
5395 if (type=="number")
5396 {
5397 listType=DocHtmlList::Ordered;
5398 }
5399 if (type=="table")
5400 {
5401 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5402 retval=children().get_last<DocHtmlTable>()->parseXml();
5403 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5404 }
5405 else
5406 {
5407 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5408 retval=children().get_last<DocHtmlList>()->parseXml();
5409 }
5410 }
5411 break;
5414 // These tags are defined in .Net but are currently unsupported
5416 break;
5418 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5419 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5420 break;
5423 break;
5424 default:
5425 // we should not get here!
5426 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5427 ASSERT(0);
5428 break;
5429 }
5430 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5431 return retval;
5432}
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1491
const DocNodeVariant * summary() const
Definition docnode.h:864
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4120
void handleLinkedWord(DocNodeVariant *parent, DocNodeList &children, bool ignoreAutoLinkFlag=FALSE)
Token handleAHref(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
void handleStyleEnter(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const QCString &tagName, const HtmlAttribList *attribs)
void handleImg(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Type type() const
Definition docnode.h:1026
void setStateXmlCode()
T & back()
access the last element
Definition growvector.h:135
static void unescapeCRef(QCString &s)
Definition docnode.cpp:81
static bool findAttribute(const HtmlAttribList &tagHtmlAttribs, const char *attrName, QCString *result)
Definition docnode.cpp:4945
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 > DocNodeVariant
Definition docnode.h:67
bool insideTable(const DocNodeVariant *n)
bool insideDL(const DocNodeVariant *n)
QCString attribsStr

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, DocParamSect::Exception, FALSE, 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(), QCString::isEmpty(), 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, TRUE, 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().

◆ handleIFile()

void DocPara::handleIFile ( char cmdChar,
const QCString & cmdName )

Definition at line 3793 of file docnode.cpp.

3794{
3795 AUTO_TRACE();
3796 Token tok=parser()->tokenizer.lex();
3797 if (!tok.is(TokenRetval::TK_WHITESPACE))
3798 {
3799 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3800 cmdChar,cmdName);
3801 return;
3802 }
3804 tok=parser()->tokenizer.lex();
3806 if (!tok.is(TokenRetval::TK_WORD))
3807 {
3808 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3809 tok.to_string(),cmdChar,cmdName);
3810 return;
3811 }
3814}

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

Referenced by handleCommand().

◆ handleILine()

void DocPara::handleILine ( char cmdChar,
const QCString & cmdName )

Definition at line 3779 of file docnode.cpp.

3780{
3781 AUTO_TRACE();
3783 Token tok = parser()->tokenizer.lex();
3784 if (!tok.is(TokenRetval::TK_WORD))
3785 {
3786 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid argument for command '{:c}{}'",
3787 cmdChar,cmdName);
3788 return;
3789 }
3791}
void setStateILine()

References AUTO_TRACE, Token::is(), DocTokenizer::lex(), DocNode::parser(), DocTokenizer::setStateILine(), DocTokenizer::setStatePara(), DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleInclude()

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

Definition at line 3984 of file docnode.cpp.

3985{
3986 AUTO_TRACE("cmdName={}",cmdName);
3987 QCString saveCmdName = cmdName;
3988 Token tok=parser()->tokenizer.lex();
3989 bool isBlock = false;
3990 bool trimLeft = false;
3991 bool localScope = false;
3992 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3993 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3994 {
3996 parser()->tokenizer.lex();
3998 StringVector optList=split(parser()->context.token->name.str(),",");
3999 auto contains = [&optList](const char *kw)
4000 {
4001 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
4002 };
4003 localScope = contains("local");
4004 if (contains("nostrip"))
4005 {
4006 stripCodeComments = false;
4007 }
4008 else if (contains("strip"))
4009 {
4010 stripCodeComments = true;
4011 }
4012 if (t==DocInclude::Snippet && contains("trimleft"))
4013 {
4014 trimLeft = true;
4015 }
4016
4017 if (contains("lineno"))
4018 {
4022 }
4023 tok=parser()->tokenizer.lex();
4024 if (!tok.is(TokenRetval::TK_WHITESPACE))
4025 {
4026 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4027 saveCmdName);
4028 return;
4029 }
4030 }
4031 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
4032 {
4034 parser()->tokenizer.lex();
4035 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
4037 parser()->tokenizer.lex();
4038 }
4039 else if (!tok.is(TokenRetval::TK_WHITESPACE))
4040 {
4041 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4042 saveCmdName);
4043 return;
4044 }
4046 tok=parser()->tokenizer.lex();
4048 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4049 {
4050 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4051 "argument of command {}",saveCmdName);
4052 return;
4053 }
4054 else if (!tok.is(TokenRetval::TK_WORD))
4055 {
4056 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
4057 tok.to_string(),saveCmdName);
4058 return;
4059 }
4060 QCString fileName = parser()->context.token->name;
4061 QCString blockId;
4063 {
4064 if (fileName == "this") fileName=parser()->context.fileName;
4066 tok=parser()->tokenizer.lex();
4068 if (!tok.is(TokenRetval::TK_WORD))
4069 {
4070 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
4071 tok.to_string(),saveCmdName);
4072 return;
4073 }
4074 blockId = "["+parser()->context.token->name+"]";
4075 }
4076
4077 children().append<DocInclude>(parser(),
4078 thisVariant(),
4079 fileName,
4080 localScope ? parser()->context.context : "",
4081 t,
4082 stripCodeComments,
4085 blockId,isBlock,trimLeft);
4086 children().get_last<DocInclude>()->parse();
4087}
@ DontIncWithLines
Definition docnode.h:439
void setStateSnippet()
void setStateBlock()

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(), QCString::stripWhiteSpace(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleIncludeOperator()

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

Definition at line 3817 of file docnode.cpp.

3818{
3819 AUTO_TRACE("cmdName={}",cmdName);
3820 QCString saveCmdName = cmdName;
3821 Token tok=parser()->tokenizer.lex();
3822 if (!tok.is(TokenRetval::TK_WHITESPACE))
3823 {
3824 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3825 saveCmdName);
3826 return;
3827 }
3829 tok=parser()->tokenizer.lex();
3831 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3832 {
3833 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3834 "argument of command {}", saveCmdName);
3835 return;
3836 }
3837 else if (!tok.is(TokenRetval::TK_WORD))
3838 {
3839 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3840 tok.to_string(),saveCmdName);
3841 return;
3842 }
3843 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3844 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3845 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3846 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3847 //TODO get from context the stripCodeComments()
3848 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3849 children().append<DocIncOperator>(parser(),thisVariant(),t,
3852 stripCodeComments,
3855 );
3856 DocIncOperator *op = children().get_last<DocIncOperator>();
3857 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3858 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3859 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3860 bool isFirst = !n1 || // no last node
3861 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3862 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3863 op->markFirst(isFirst);
3864 op->markLast(true);
3865 if (n1_docIncOp)
3866 {
3867 n1_docIncOp->markLast(false);
3868 }
3869 else if (n1_docWs && n2_docIncOp)
3870 {
3871 n2_docIncOp->markLast(false);
3872 }
3873 op->parse();
3874}
void markLast(bool v=TRUE)
Definition docnode.h:505
bool isFirst() const
Definition docnode.h:1087
void setStatePattern()
size_t size() const
returns the number of elements
Definition growvector.h:93
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 4174 of file docnode.cpp.

4175{
4176 if (parser()->context.memberDef) // inheriting docs from a member
4177 {
4178 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4179 if (reMd) // member from which was inherited.
4180 {
4181 const MemberDef *thisMd = parser()->context.memberDef;
4182 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4183 parser()->pushContext();
4184 parser()->context.scope=reMd->getOuterScope();
4185 if (parser()->context.scope!=Doxygen::globalScope)
4186 {
4188 }
4189 parser()->context.memberDef=reMd;
4190 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4191 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4192 parser()->context.copyStack.push_back(reMd);
4195 parser()->context.copyStack.pop_back();
4196 auto hasParamCommand = parser()->context.hasParamCommand;
4197 auto hasReturnCommand = parser()->context.hasReturnCommand;
4198 auto retvalsFound = parser()->context.retvalsFound;
4199 auto paramsFound = parser()->context.paramsFound;
4200 parser()->popContext();
4201 parser()->context.hasParamCommand = hasParamCommand;
4202 parser()->context.hasReturnCommand = hasReturnCommand;
4203 parser()->context.retvalsFound = retvalsFound;
4204 parser()->context.paramsFound = paramsFound;
4205 parser()->context.memberDef = thisMd;
4206 }
4207 }
4208}
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
virtual QCString documentation() const =0
virtual Definition * getOuterScope() const =0
virtual const QCString & name() const =0
Token internalValidatingParseDoc(DocNodeVariant *parent, DocNodeList &children, const QCString &doc)
void popContext()
Definition docparser.cpp:74
void pushContext()
Definition docparser.cpp:60
virtual const MemberDef * reimplements() const =0
StringMultiSet retvalsFound
Definition docparser_p.h:76
DocStyleChangeStack styleStack
Definition docparser_p.h:68
StringMultiSet paramsFound
Definition docparser_p.h:77
DefinitionStack copyStack
Definition docparser_p.h:70

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(), DocParser::popContext(), DocParser::pushContext(), MemberDef::reimplements(), DocParserContext::retvalsFound, DocParserContext::scope, DocParserContext::styleStack, and DocNode::thisVariant().

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleLink()

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

Definition at line 3916 of file docnode.cpp.

3917{
3918 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3919 QCString saveCmdName = cmdName;
3920 Token tok=parser()->tokenizer.lex();
3921 if (!tok.is(TokenRetval::TK_WHITESPACE))
3922 {
3923 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3924 saveCmdName);
3925 return;
3926 }
3928 tok=parser()->tokenizer.lex();
3929 if (!tok.is(TokenRetval::TK_WORD))
3930 {
3931 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3932 tok.to_string(),saveCmdName);
3933 return;
3934 }
3935 if (saveCmdName == "javalink")
3936 {
3937 children().append<DocStyleChange>(parser(),thisVariant(),
3938 parser()->context.nodeStack.size(),
3939 DocStyleChange::Code,cmdName,TRUE);
3940 }
3943 DocLink *lnk = children().get_last<DocLink>();
3944 if (saveCmdName == "javalink")
3945 {
3946 children().append<DocStyleChange>(parser(),thisVariant(),
3947 parser()->context.nodeStack.size(),
3948 DocStyleChange::Code,cmdName,FALSE);
3949 }
3950 QCString leftOver = lnk->parse(isJavaLink);
3951 if (!leftOver.isEmpty())
3952 {
3953 children().append<DocWord>(parser(),thisVariant(),leftOver);
3954 }
3955}
void setStateLink()

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

Referenced by handleCommand().

◆ handleParamSection()

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

Definition at line 3431 of file docnode.cpp.

3435{
3436 AUTO_TRACE();
3437 DocParamSect *ps = nullptr;
3438 if (!children().empty() && // previous element
3439 (ps=children().get_last<DocParamSect>()) && // was a param sect
3440 ps->type()==t) // of same type
3441 { // append to previous section ps
3442 }
3443 else // start new section
3444 {
3445 children().append<DocParamSect>(parser(),thisVariant(),t);
3446 ps = children().get_last<DocParamSect>();
3447 }
3448 Token rv=ps->parse(cmdName,xmlContext,
3449 static_cast<DocParamSect::Direction>(direction));
3450 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3451 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3452}
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3352
Type type() const
Definition docnode.h:1068

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleRef()

void DocPara::handleRef ( char cmdChar,
const QCString & cmdName )

Definition at line 3957 of file docnode.cpp.

3958{
3959 AUTO_TRACE("cmdName={}",cmdName);
3960 QCString 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 '{:c}{}' command",
3965 cmdChar,qPrint(saveCmdName));
3966 return;
3967 }
3969 tok=parser()->tokenizer.lex(); // get the reference id
3970 if (!tok.is(TokenRetval::TK_WORD))
3971 {
3972 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3973 tok.to_string(),cmdChar,saveCmdName);
3974 goto endref;
3975 }
3976 children().append<DocRef>(parser(),thisVariant(),
3979 children().get_last<DocRef>()->parse();
3980endref:
3982}
const char * qPrint(const char *s)
Definition qcstring.h:687

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

Referenced by handleCommand().

◆ handleSection()

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

Definition at line 4089 of file docnode.cpp.

4090{
4091 AUTO_TRACE("cmdName={}",cmdName);
4092 QCString saveCmdName = cmdName;
4093 // get the argument of the section command.
4094 Token tok=parser()->tokenizer.lex();
4095 if (!tok.is(TokenRetval::TK_WHITESPACE))
4096 {
4097 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4098 cmdChar,saveCmdName);
4099 return;
4100 }
4101 tok=parser()->tokenizer.lex();
4102 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4103 {
4104 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4105 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4106 return;
4107 }
4108 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4109 {
4110 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4111 tok.to_string(),cmdChar,saveCmdName);
4112 return;
4113 }
4116 parser()->tokenizer.lex();
4118}
void setStateSkipTitle()

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 QCString & cmdName )

Definition at line 3709 of file docnode.cpp.

3710{
3711 AUTO_TRACE();
3712 QCString fmt;
3713 QCString date;
3714 Token tok=parser()->tokenizer.lex();
3715 if (!tok.is(TokenRetval::TK_WHITESPACE))
3716 {
3717 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3718 cmdChar,cmdName);
3719 return;
3720 }
3722 tok = parser()->tokenizer.lex();
3723 if (!tok.is(TokenRetval::TK_WORD))
3724 {
3725 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3726 cmdChar,cmdName);
3728 return;
3729 }
3730 fmt = parser()->context.token->name;
3731
3733 tok = parser()->tokenizer.lex();
3734
3735 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3736 QCString specDate = specDateRaw.stripWhiteSpace();
3737 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3738 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3739 {
3740 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3741 cmdChar,cmdName);
3743 return;
3744 }
3745
3746 std::tm dat{};
3747 int specFormat=0;
3748 QCString err = dateTimeFromString(specDate,dat,specFormat);
3749 if (!err.isEmpty())
3750 {
3751 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3752 cmdChar,cmdName,err);
3754 return;
3755 }
3756
3757 int usedFormat=0;
3758 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3759
3760 // warn the user if the format contains markers that are not explicitly filled in
3761 for (int i=0;i<SF_NumBits;i++)
3762 {
3763 int bitMask = 1<<i;
3764 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3765 {
3766 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.",
3767 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3768 }
3769 }
3770
3771 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3772 if (specDateOnlyWS) // specDate is only whitespace
3773 {
3774 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3775 }
3777}
void setStateShowDate()
void setStateQuotedString()
QCString formatDateTime(const QCString &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:175
QCString dateTimeFromString(const QCString &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:134
constexpr const char * SF_bit2str(int bitNumber)
Helper function that returns the name related one of the SF bits.
Definition datetime.h:32
constexpr int SF_NumBits
number of bits in SF vector
Definition datetime.h:27
#define err(fmt,...)
Definition message.h:127

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, dateTimeFromString(), err, formatDateTime(), Token::is(), Token::is_any_of(), QCString::isEmpty(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), DocTokenizer::setStateQuotedString(), DocTokenizer::setStateShowDate(), SF_bit2str(), SF_NumBits, QCString::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 3401 of file docnode.cpp.

3402{
3403 AUTO_TRACE();
3404 DocSimpleSect *ss=nullptr;
3405 bool needsSeparator = FALSE;
3406 if (!children().empty() && // has previous element
3407 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3408 ss->type()==t && // of same type
3409 t!=DocSimpleSect::User) // but not user defined
3410 {
3411 // append to previous section
3412 needsSeparator = TRUE;
3413 }
3414 else // start new section
3415 {
3416 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3417 ss = children().get_last<DocSimpleSect>();
3418 }
3419 Token rv = Token::make_RetVal_OK();
3420 if (xmlContext)
3421 {
3422 return ss->parseXml();
3423 }
3424 else
3425 {
3426 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3427 }
3428 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3429}
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3066
Token parseXml()
Definition docnode.cpp:3120

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 4138 of file docnode.cpp.

4139{
4140 AUTO_TRACE();
4141 Token retval = parser()->tokenizer.lex();
4142 QCString lang = parser()->context.token->name;
4143 if (!lang.isEmpty() && lang.at(0)!='.')
4144 {
4145 lang="."+lang;
4146 }
4147 if (parser()->context.xmlComment)
4148 {
4149 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4150 }
4151 // search for the first non-whitespace line, index is stored in li
4152 size_t i=0,li=0,l=parser()->context.token->verb.length();
4153 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4154 {
4155 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4156 i++;
4157 }
4158 children().append<DocVerbatim>(parser(),thisVariant(),
4160 stripIndentation(parser()->context.token->verb.mid(li)),
4164 FALSE,lang);
4165 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4166 {
4167 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4168 }
4170 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4171 return retval;
4172}
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482
QCString stripIndentation(const QCString &s, bool skipFirstLine)
Definition util.cpp:6468

References DocNodeList::append(), QCString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), DocVerbatim::Code, DocParser::context, DocParserContext::context, DocParserContext::exampleName, FALSE, Token::is_any_of(), QCString::isEmpty(), DocParserContext::isExample, QCString::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 3909 of file docnode.cpp.

3910{
3911 AUTO_TRACE();
3912 children().append<DocVhdlFlow>(parser(),thisVariant());
3913 children().get_last<DocVhdlFlow>()->parse();
3914}

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 3688 of file docnode.cpp.

3689{
3690 AUTO_TRACE();
3691 Token retval=parser()->tokenizer.lex();
3692 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3694 retval=parser()->tokenizer.lex();
3695 if (retval.is(TokenRetval::RetVal_OK))
3696 {
3697 children().append<DocXRefItem>(parser(),thisVariant(),
3699 DocXRefItem *ref = children().get_last<DocXRefItem>();
3700 if (!ref->parse())
3701 {
3702 children().pop_back();
3703 }
3704 }
3706 return retval;
3707}
void setStateXRefItem()

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 QCString & tokText )

Definition at line 4131 of file docnode.cpp.

4132{
4133 AUTO_TRACE();
4134 parser()->context.token->name = tokText;
4135 return parser()->defaultHandleToken(thisVariant(),tok,children());
4136}
bool defaultHandleToken(DocNodeVariant *parent, Token tok, DocNodeList &children, bool handleWord=TRUE)

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

Referenced by DocSimpleSect::appendLinkWord().

◆ isEmpty()

bool DocPara::isEmpty ( ) const
inline

Definition at line 1084 of file docnode.h.

1084{ return children().empty(); }
bool empty() const
checks whether the container is empty
Definition growvector.h:140

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

◆ isFirst()

bool DocPara::isFirst ( ) const
inline

Definition at line 1087 of file docnode.h.

1087{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

◆ markFirst()

◆ markLast()

◆ parse()

Token DocPara::parse ( )

Definition at line 5707 of file docnode.cpp.

5708{
5709 AUTO_TRACE();
5710 auto ns = AutoNodeStack(parser(),thisVariant());
5711 // handle style commands "inherited" from the previous paragraph
5713 Token tok=parser()->tokenizer.lex();
5714 Token retval = Token::make_TK_NONE();
5715 while (!tok.is_any_of(TokenRetval::TK_NONE, TokenRetval::TK_EOF)) // get the next token
5716 {
5717reparsetoken:
5718 AUTO_TRACE_ADD("token '{}' at {}",tok.to_string(),parser()->tokenizer.getLineNr());
5719 if (tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD,TokenRetval::TK_SYMBOL,TokenRetval::TK_URL,
5720 TokenRetval::TK_COMMAND_AT,TokenRetval::TK_COMMAND_BS,TokenRetval::TK_HTMLTAG)
5721 )
5722 {
5723 AUTO_TRACE_ADD("name={}",parser()->context.token->name);
5724 }
5725 switch(tok.value())
5726 {
5727 case TokenRetval::TK_WORD:
5729 break;
5730 case TokenRetval::TK_LNKWORD:
5732 break;
5733 case TokenRetval::TK_URL:
5735 break;
5736 case TokenRetval::TK_WHITESPACE:
5737 {
5738 // prevent leading whitespace and collapse multiple whitespace areas
5739 if (insidePRE(thisVariant()) || // all whitespace is relevant
5740 (
5741 // remove leading whitespace
5742 !children().empty() &&
5743 // and whitespace after certain constructs
5744 !holds_one_of_alternatives<DocHtmlDescList, DocHtmlTable, DocHtmlList, DocSimpleSect,
5745 DocAutoList, DocSimpleList, DocHtmlHeader, DocHtmlBlockQuote,
5746 DocParamSect, DocHtmlDetails, DocXRefItem>(children().back())
5747 )
5748 )
5749 {
5750 children().append<DocWhiteSpace>(parser(),thisVariant(),parser()->context.token->chars);
5751 }
5752 }
5753 break;
5754 case TokenRetval::TK_LISTITEM:
5755 {
5756 AUTO_TRACE_ADD("found list item at {}",parser()->context.token->indent);
5757 const DocNodeVariant *n=parent();
5758 while (n && !std::holds_alternative<DocAutoList>(*n)) n=::parent(n);
5759 const DocAutoList *al = std::get_if<DocAutoList>(n);
5760 if (al) // we found an auto list up in the hierarchy
5761 {
5762 AUTO_TRACE_ADD("previous list item at {}",al->indent());
5763 if (al->indent()>=parser()->context.token->indent)
5764 // new item at the same or lower indent level
5765 {
5766 retval = Token::make_TK_LISTITEM();
5767 goto endparagraph;
5768 }
5769 }
5770
5771 // determine list depth
5772 int depth = 0;
5773 n=parent();
5774 while (n)
5775 {
5776 al = std::get_if<DocAutoList>(n);
5777 if (al && al->isEnumList()) depth++;
5778 n=::parent(n);
5779 }
5780
5781 // first item or sub list => create new list
5782 do
5783 {
5784 children().append<DocAutoList>(parser(),thisVariant(),
5786 parser()->context.token->isEnumList,depth,
5788 al = children().get_last<DocAutoList>();
5789 retval = children().get_last<DocAutoList>()->parse();
5790 } while (retval.is(TokenRetval::TK_LISTITEM) && // new list
5791 al->indent()==parser()->context.token->indent // at same indent level
5792 );
5793
5794 // check the return value
5795 if (retval.is(TokenRetval::RetVal_SimpleSec)) // auto list ended due to simple section command
5796 {
5797 // Reparse the token that ended the section at this level,
5798 // so a new simple section will be started at this level.
5799 // This is the same as unputting the last read token and continuing.
5801 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5802 {
5805 tok = Token::make_TK_RCSTAG();
5806 }
5807 else // other section
5808 {
5809 tok = Token::make_TK_COMMAND_BS();
5810 }
5811 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5812 goto reparsetoken;
5813 }
5814 else if (retval.is(TokenRetval::TK_ENDLIST))
5815 {
5816 if (al->indent()>parser()->context.token->indent) // end list
5817 {
5818 goto endparagraph;
5819 }
5820 else // continue with current paragraph
5821 {
5822 }
5823 }
5824 else // paragraph ended due to TokenRetval::TK_NEWPARA, TokenRetval::TK_LISTITEM, or EOF
5825 {
5826 goto endparagraph;
5827 }
5828 }
5829 break;
5830 case TokenRetval::TK_ENDLIST:
5831 AUTO_TRACE_ADD("Found end of list inside of paragraph at line {}",parser()->tokenizer.getLineNr());
5832 if (std::get_if<DocAutoListItem>(parent()))
5833 {
5834 const DocAutoList *al = std::get_if<DocAutoList>(::parent(parent()));
5835 if (al && al->indent()>=parser()->context.token->indent)
5836 {
5837 // end of list marker ends this paragraph
5838 retval = Token::make_TK_ENDLIST();
5839 goto endparagraph;
5840 }
5841 else
5842 {
5843 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found "
5844 "has invalid indent level");
5845 }
5846 }
5847 else
5848 {
5849 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found without any preceding "
5850 "list items");
5851 }
5852 break;
5853 case TokenRetval::TK_COMMAND_AT:
5854 // fall through
5855 case TokenRetval::TK_COMMAND_BS:
5856 {
5857 // see if we have to start a simple section
5858 CommandType cmd = Mappers::cmdMapper->map(parser()->context.token->name);
5859 const DocNodeVariant *n=parent();
5860 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5861 !std::holds_alternative<DocParamSect>(*n))
5862 {
5863 n=::parent(n);
5864 }
5866 {
5867 if (n) // already in a simple section
5868 {
5869 // simple section cannot start in this paragraph, need
5870 // to unwind the stack and remember the command.
5872 retval = Token::make_RetVal_SimpleSec();
5873 goto endparagraph;
5874 }
5875 }
5876 // see if we are in a simple list
5877 n=parent();
5878 while (n && !std::holds_alternative<DocSimpleListItem>(*n)) n=::parent(n);
5879 if (n)
5880 {
5881 if (cmd==CommandType::CMD_LI)
5882 {
5883 retval = Token::make_RetVal_ListItem();
5884 goto endparagraph;
5885 }
5886 }
5887
5888 // handle the command
5889 retval=handleCommand(tok.command_to_char(),parser()->context.token->name);
5890 AUTO_TRACE_ADD("handleCommand returns {}",retval.to_string());
5891
5892 // check the return value
5893 if (retval.is(TokenRetval::RetVal_SimpleSec))
5894 {
5895 // Reparse the token that ended the section at this level,
5896 // so a new simple section will be started at this level.
5897 // This is the same as unputting the last read token and continuing.
5899 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5900 {
5903 tok = Token::make_TK_RCSTAG();
5904 }
5905 else // other section
5906 {
5907 tok = Token::make_TK_COMMAND_BS();
5908 }
5909 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5910 goto reparsetoken;
5911 }
5912 else if (retval.value()>TokenRetval::TK_NONE && retval.value()<TokenRetval::RetVal_OK)
5913 {
5914 // the command ended with a new command, reparse this token
5915 tok = retval;
5916 goto reparsetoken;
5917 }
5918 else if (retval.value()!=TokenRetval::RetVal_OK) // end of file, end of paragraph, start or end of section
5919 // or some auto list marker
5920 {
5921 goto endparagraph;
5922 }
5923 }
5924 break;
5925 case TokenRetval::TK_HTMLTAG:
5926 {
5927 if (!parser()->context.token->endTag) // found a start tag
5928 {
5929 retval = handleHtmlStartTag(parser()->context.token->name,parser()->context.token->attribs);
5930 }
5931 else // found an end tag
5932 {
5934 {
5935 break; // new code has been pushed back to the scanner, need to reparse
5936 }
5937 retval = handleHtmlEndTag(parser()->context.token->name);
5938 }
5939 if (!retval.is(TokenRetval::RetVal_OK))
5940 {
5941 goto endparagraph;
5942 }
5943 }
5944 break;
5945 case TokenRetval::TK_SYMBOL:
5946 {
5947 HtmlEntityMapper::SymType s = DocSymbol::decodeSymbol(parser()->context.token->name);
5949 {
5950 children().append<DocSymbol>(parser(),thisVariant(),s);
5951 }
5952 else
5953 {
5955 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported symbol '{}' found",
5956 parser()->context.token->name);
5957 }
5958 break;
5959 }
5960 case TokenRetval::TK_NEWPARA:
5961 retval = Token::make_TK_NEWPARA();
5962 goto endparagraph;
5963 case TokenRetval::TK_RCSTAG:
5964 {
5965 const DocNodeVariant *n=parent();
5966 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5967 !std::holds_alternative<DocParamSect>(*n))
5968 {
5969 n=::parent(n);
5970 }
5971 if (n) // already in a simple section
5972 {
5973 // simple section cannot start in this paragraph, need
5974 // to unwind the stack and remember the command.
5977 retval = Token::make_RetVal_SimpleSec();
5978 goto endparagraph;
5979 }
5980
5981 // see if we are in a simple list
5982 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::Rcs);
5983 children().get_last<DocSimpleSect>()->parseRcs();
5984 }
5985 break;
5986 default:
5987 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
5988 "Found unexpected token (id={})",tok.to_string());
5989 break;
5990 }
5991 tok=parser()->tokenizer.lex();
5992 }
5993 retval=Token::make_TK_NONE();
5994endparagraph:
5996 DocPara *par = std::get_if<DocPara>(parser()->context.nodeStack.top());
5997 if (!parser()->context.token->endTag && par &&
5998 retval.is(TokenRetval::TK_NEWPARA) && parser()->context.token->name.lower() == "p")
5999 {
6000 par->setAttribs(parser()->context.token->attribs);
6001 }
6002 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::TK_NEWPARA,TokenRetval::TK_LISTITEM,
6003 TokenRetval::TK_ENDLIST,TokenRetval::RetVal_OK)
6004 );
6005
6006 AUTO_TRACE_EXIT("retval={}",retval.to_string());
6007 return retval;
6008}
bool isEnumList() const
Definition docnode.h:580
int indent() const
Definition docnode.h:581
DocPara(DocParser *parser, DocNodeVariant *parent)
Definition docnode.cpp:3395
Token handleCommand(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4211
Token handleHtmlStartTag(const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Definition docnode.cpp:4961
void setAttribs(const HtmlAttribList &attribs)
Definition docnode.h:1115
Token handleHtmlEndTag(const QCString &tagName)
Definition docnode.cpp:5434
void handleInitialStyleCommands(DocNodeVariant *parent, DocNodeList &children)
void handlePendingStyleCommands(DocNodeVariant *parent, DocNodeList &children)
static HtmlEntityMapper::SymType decodeSymbol(const QCString &symName)
Definition docnode.cpp:152
TokenRetval value() const
char command_to_char() const
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
static bool checkIfHtmlEndTagEndsAutoList(DocParser *parser, const DocNodeVariant *n)
Definition docnode.cpp:5655
constexpr bool holds_one_of_alternatives(const DocNodeVariant &v)
returns true iff v holds one of types passed as template parameters
Definition docnode.h:1366
bool insidePRE(const DocNodeVariant *n)
bool isEnumList
QCString text
QCString chars
bool isCheckedList
QCString simpleSectText
bool isEMailAddr
QCString simpleSectName

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(), 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(), QCString::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(), handleRef(), 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 1115 of file docnode.h.

1115{ m_attribs = attribs; }
const HtmlAttribList & attribs() const
Definition docnode.h:1114

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1120 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1118 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1119 of file docnode.h.

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


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