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

3390 :
3393{
3394}
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 3449 of file docnode.cpp.

3450{
3451 AUTO_TRACE();
3452 QCString saveCmdName = cmdName;
3453 // get the argument of the cite command.
3454 Token tok=parser()->tokenizer.lex();
3455
3456 CiteInfoOption option;
3457 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3458 {
3460 parser()->tokenizer.lex();
3461 StringVector optList=split(parser()->context.token->name.str(),",");
3462 for (auto const &opt : optList)
3463 {
3464 if (opt == "number")
3465 {
3466 if (!option.isUnknown())
3467 {
3468 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3469 }
3470 else
3471 {
3472 option = CiteInfoOption::makeNumber();
3473 }
3474 }
3475 else if (opt == "year")
3476 {
3477 if (!option.isUnknown())
3478 {
3479 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3480 }
3481 else
3482 {
3483 option = CiteInfoOption::makeYear();
3484 }
3485 }
3486 else if (opt == "shortauthor")
3487 {
3488 if (!option.isUnknown())
3489 {
3490 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3491 }
3492 else
3493 {
3495 }
3496 }
3497 else if (opt == "nopar")
3498 {
3499 option.setNoPar();
3500 }
3501 else if (opt == "nocite")
3502 {
3503 option.setNoCite();
3504 }
3505 else
3506 {
3507 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unknown option specified with \\{}, discarding '{}'", saveCmdName, opt);
3508 }
3509 }
3510
3511 if (option.isUnknown()) option.changeToNumber();
3512
3514 tok=parser()->tokenizer.lex();
3515 if (!tok.is(TokenRetval::TK_WHITESPACE))
3516 {
3517 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3518 saveCmdName);
3519 return;
3520 }
3521 }
3522 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3523 {
3524 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3525 cmdChar,saveCmdName);
3526 return;
3527 }
3528 else
3529 {
3530 option = CiteInfoOption::makeNumber();
3531 }
3532
3534 tok=parser()->tokenizer.lex();
3535 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3536 {
3537 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"THE ONE unexpected end of comment block while parsing the "
3538 "argument of command '{:c}{}'",cmdChar,saveCmdName);
3539 return;
3540 }
3541 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3542 {
3543 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3544 tok.to_string(),cmdChar,saveCmdName);
3545 return;
3546 }
3548 children().append<DocCite>(
3550
3552}
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 4206 of file docnode.cpp.

4207{
4208 AUTO_TRACE("cmdName={}",cmdName);
4209 Token retval = Token::make_RetVal_OK();
4210 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
4211 switch (cmdId)
4212 {
4214 {
4215 std::string str{cmdChar};
4216 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
4217 if (isAliasCmd(cmdName.view()))
4218 {
4219 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
4220 }
4221 else
4222 {
4223 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4224 }
4225 }
4226 break;
4228 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,TRUE);
4229 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4230 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,FALSE);
4231 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4232 break;
4234 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,TRUE);
4235 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4236 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,FALSE);
4237 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4238 break;
4240 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,TRUE);
4241 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4242 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,FALSE);
4243 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4244 break;
4247 break;
4250 break;
4253 break;
4256 break;
4259 break;
4262 break;
4265 break;
4268 break;
4271 break;
4274 break;
4278 break;
4283 break;
4286 break;
4289 break;
4292 break;
4295 break;
4298 break;
4301 break;
4304 break;
4309 break;
4313 break;
4316 break;
4319 break;
4322 break;
4325 break;
4328 break;
4331 break;
4334 break;
4337 break;
4340 break;
4343 break;
4346 break;
4349 break;
4352 break;
4355 break;
4358 break;
4360 {
4361 children().append<DocSimpleList>(parser(),thisVariant());
4362 retval = children().get_last<DocSimpleList>()->parse();
4363 }
4364 break;
4366 {
4367 handleSection(cmdChar,cmdName);
4368 retval = Token::make_RetVal_Section();
4369 }
4370 break;
4372 {
4373 handleSection(cmdChar,cmdName);
4374 retval = Token::make_RetVal_Subsection();
4375 }
4376 break;
4378 {
4379 handleSection(cmdChar,cmdName);
4380 retval = Token::make_RetVal_Subsubsection();
4381 }
4382 break;
4384 {
4385 handleSection(cmdChar,cmdName);
4386 retval = Token::make_RetVal_Paragraph();
4387 }
4388 break;
4390 {
4391 handleSection(cmdChar,cmdName);
4392 retval = Token::make_RetVal_SubParagraph();
4393 }
4394 break;
4396 {
4397 handleSection(cmdChar,cmdName);
4398 retval = Token::make_RetVal_SubSubParagraph();
4399 }
4400 break;
4402 {
4404 retval = handleStartCode();
4405 }
4406 break;
4408 {
4410 retval = handleStartCode();
4411 }
4412 break;
4414 {
4416 retval = parser()->tokenizer.lex();
4418 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4419 {
4420 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4421 }
4423 }
4424 break;
4426 {
4428 retval = parser()->tokenizer.lex();
4430 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4431 {
4432 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4433 }
4435 }
4436 break;
4438 {
4440 retval = parser()->tokenizer.lex();
4442 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4443 {
4444 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4445 }
4447 }
4448 break;
4450 {
4452 retval = parser()->tokenizer.lex();
4454 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4455 {
4456 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4457 }
4459 }
4460 break;
4462 {
4464 retval = parser()->tokenizer.lex();
4466 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4467 {
4468 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4469 }
4471 }
4472 break;
4474 {
4476 retval = parser()->tokenizer.lex();
4478 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4479 {
4480 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4481 }
4483 }
4484 break;
4486 {
4489 parser()->tokenizer.lex();
4490
4491 QCString fullMatch = parser()->context.token->verb;
4492 int idx = fullMatch.find('{');
4493 int idxEnd = fullMatch.find("}",idx+1);
4494 StringVector optList;
4495 if (idx != -1) // options present
4496 {
4497 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4498 optList = split(optStr.str(),",");
4499 for (const auto &opt : optList)
4500 {
4501 if (opt.empty()) continue;
4502 QCString locOpt(opt);
4503 locOpt = locOpt.stripWhiteSpace().lower();
4504 if (locOpt == "code")
4505 {
4507 }
4508 else if (!locOpt.isEmpty())
4509 {
4510 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4511 }
4512 }
4513 }
4514
4516 retval = parser()->tokenizer.lex();
4518 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4519 {
4520 if (t == DocVerbatim::JavaDocCode)
4521 {
4522 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4523 }
4524 else
4525 {
4526 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4527 }
4528 }
4530 }
4531 break;
4534 {
4535 if (cmdId == CommandType::CMD_VERBATIM)
4536 {
4538 }
4539 else
4540 {
4542 }
4543 retval = parser()->tokenizer.lex();
4545 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4546 {
4547 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4548 }
4550 }
4551 break;
4553 {
4554 children().append<DocVerbatim>(parser(),thisVariant(),
4560 DocVerbatim *dv = children().get_last<DocVerbatim>();
4562 QCString width,height;
4563 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4565 retval = parser()->tokenizer.lex();
4566 dv->setText(parser()->context.token->verb);
4567 dv->setWidth(width);
4568 dv->setHeight(height);
4569 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4570 if (!Config_getBool(HAVE_DOT))
4571 {
4572 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4573 children().pop_back();
4574 }
4575 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4576 {
4577 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4578 }
4580 }
4581 break;
4583 {
4584 children().append<DocVerbatim>(parser(),thisVariant(),
4590 DocVerbatim *dv = children().get_last<DocVerbatim>();
4592 QCString width,height;
4593 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4595 retval = parser()->tokenizer.lex();
4596 dv->setText(parser()->context.token->verb);
4597 dv->setWidth(width);
4598 dv->setHeight(height);
4599 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4600 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4601 {
4602 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4603 }
4605 }
4606 break;
4608 {
4609 QCString jarPath = Config_getString(PLANTUML_JAR_PATH);
4611 parser()->tokenizer.lex();
4612 QCString fullMatch = parser()->context.token->sectionId;
4613 QCString sectionId = "";
4614 int idx = fullMatch.find('{');
4615 int idxEnd = fullMatch.find("}",idx+1);
4616 StringVector optList;
4617 QCString engine;
4618 if (idx != -1) // options present
4619 {
4620 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4621 optList = split(optStr.str(),",");
4622 for (const auto &opt : optList)
4623 {
4624 if (opt.empty()) continue;
4625 bool found = false;
4626 QCString locOpt(opt);
4627 locOpt = locOpt.stripWhiteSpace().lower();
4628 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4629 {
4630 if (!engine.isEmpty())
4631 {
4632 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4633 }
4634 engine = locOpt;
4635 found = true;
4636 }
4637 if (!found)
4638 {
4639 if (sectionId.isEmpty())
4640 {
4641 sectionId = opt;
4642 }
4643 else
4644 {
4645 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4646 }
4647 }
4648 }
4649 }
4650 else
4651 {
4652 sectionId = parser()->context.token->sectionId;
4653 }
4654 if (engine.isEmpty()) engine = "uml";
4655
4656 if (sectionId.isEmpty())
4657 {
4659 retval = parser()->tokenizer.lex();
4660 assert(retval.is(TokenRetval::RetVal_OK));
4661
4662 sectionId = parser()->context.token->sectionId;
4663 sectionId = sectionId.stripWhiteSpace();
4664 }
4665
4666 QCString plantFile(sectionId);
4667 children().append<DocVerbatim>(parser(),thisVariant(),
4671 FALSE,plantFile);
4672 DocVerbatim *dv = children().get_last<DocVerbatim>();
4673 dv->setEngine(engine);
4675 QCString width,height;
4676 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4678 retval = parser()->tokenizer.lex();
4679 int line = 0;
4680 QCString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4681 if (engine == "ditaa")
4682 {
4683 dv->setUseBitmap(true);
4684 }
4685 else if (engine == "uml")
4686 {
4687 int i = trimmedVerb.find('\n');
4688 QCString firstLine = i==-1 ? trimmedVerb : trimmedVerb.left(i);
4689 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4690 }
4691 dv->setText(trimmedVerb);
4692 dv->setWidth(width);
4693 dv->setHeight(height);
4694 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4695 if (jarPath.isEmpty())
4696 {
4697 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because PLANTUML_JAR_PATH is not set");
4698 children().pop_back();
4699 }
4700 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4701 {
4702 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4703 }
4705 }
4706 break;
4708 retval = Token::make_RetVal_EndParBlock();
4709 break;
4725 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4726 break;
4728 retval = handleParamSection(cmdName,DocParamSect::Param,FALSE,parser()->context.token->paramDir);
4729 break;
4731 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,FALSE,parser()->context.token->paramDir);
4732 break;
4734 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4735 break;
4738 break;
4740 retval = handleXRefItem();
4741 break;
4743 {
4744 children().append<DocLineBreak>(parser(),thisVariant());
4745 }
4746 break;
4749 {
4751 }
4752 break;
4754 {
4756 }
4757 break;
4759 {
4760 children().append<DocIndexEntry>(parser(),thisVariant(),
4763 retval = children().get_last<DocIndexEntry>()->parse();
4764 }
4765 break;
4767 retval = Token::make_RetVal_Internal();
4768 break;
4770 retval = Token::make_RetVal_EndInternal();
4771 break;
4773 {
4774 children().append<DocParBlock>(parser(),thisVariant());
4775 retval = children().get_last<DocParBlock>()->parse();
4776 }
4777 break;
4778 case CommandType::CMD_COPYDOC: // fall through
4779 case CommandType::CMD_COPYBRIEF: // fall through
4781 //retval = Token::make_RetVal_CopyDoc();
4782 // these commands should already be resolved by processCopyDoc()
4783 break;
4786 break;
4789 break;
4792 break;
4795 break;
4798 break;
4801 break;
4804 break;
4807 break;
4810 break;
4813 break;
4816 break;
4819 break;
4822 break;
4825 break;
4828 break;
4831 break;
4834 break;
4836 if (!Config_getBool(HAVE_DOT))
4837 {
4838 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4839 "ignoring \\dotfile command because HAVE_DOT is not set");
4840 }
4841 else
4842 {
4843 handleFile<DocDotFile>(cmdName);
4844 }
4845 break;
4848 break;
4850 handleFile<DocMscFile>(cmdName);
4851 break;
4853 handleFile<DocDiaFile>(cmdName);
4854 break;
4857 break;
4859 handleLink(cmdName,FALSE);
4860 break;
4862 handleLink(cmdName,TRUE);
4863 break;
4865 handleCite(cmdChar,cmdName);
4866 break;
4868 handleEmoji(cmdChar,cmdName);
4869 break;
4871 handleDoxyConfig(cmdChar,cmdName);
4872 break;
4873 case CommandType::CMD_REF: // fall through
4875 handleRef(cmdChar,cmdName);
4876 break;
4878 {
4879 children().append<DocSecRefList>(parser(),thisVariant());
4880 children().get_last<DocSecRefList>()->parse();
4881 }
4882 break;
4884 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4885 break;
4887 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4888 break;
4890 {
4891 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4892 }
4893 break;
4894 //case CommandType::CMD_LANGSWITCH:
4895 // retval = handleLanguageSwitch();
4896 // break;
4898 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4899 {
4902 }
4903 break;
4906 break;
4908 handleShowDate(cmdChar,cmdName);
4909 break;
4911 handleILine(cmdChar,cmdName);
4912 break;
4914 handleIFile(cmdChar,cmdName);
4915 break;
4917 {
4919 (void)parser()->tokenizer.lex();
4921 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
4923 }
4924 break;
4925 default:
4926 // we should not get here!
4927 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
4928 break;
4929 }
4930 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
4931 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
4932 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
4933 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
4934 TokenRetval::RetVal_EndInternal)
4935 );
4936 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4937 return retval;
4938}
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:3396
void handleLink(const QCString &cmdName, bool isJavaLink)
Definition docnode.cpp:3911
void handleInheritDoc()
Definition docnode.cpp:4169
void handleCite(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3449
void handleInclude(const QCString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3979
void handleDoxyConfig(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3585
void handleSection(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4084
void handleFile(const QCString &cmdName)
Definition docnode.cpp:3872
void handleIFile(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3788
Token handleParamSection(const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3426
void handleEmoji(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3554
void handleIncludeOperator(const QCString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3812
void handleRef(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3952
void handleILine(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3774
Token parse()
Definition docnode.cpp:5702
void handleVhdlFlow()
Definition docnode.cpp:3904
void handleShowDate(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3704
Token handleXRefItem()
Definition docnode.cpp:3683
Token handleStartCode()
Definition docnode.cpp:4133
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:226
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:150
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:245
const std::string & str() const
Definition qcstring.h:537
std::string_view view() const
Definition qcstring.h:161
QCString left(size_t len) const
Definition qcstring.h:214
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 3585 of file docnode.cpp.

3586{
3587 // get the argument of the cite command.
3588 Token tok=parser()->tokenizer.lex();
3589 if (!tok.is(TokenRetval::TK_WHITESPACE))
3590 {
3591 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3592 cmdChar,cmdName);
3593 return;
3594 }
3596 tok=parser()->tokenizer.lex();
3597 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3598 {
3599 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3600 "argument of command '{:c}{}'",cmdChar,cmdName);
3601 return;
3602 }
3603 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3604 {
3605 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3606 tok.to_string(),cmdChar,cmdName);
3607 return;
3608 }
3609 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3610 if (opt)
3611 {
3612 QCString optionValue;
3613 switch (opt->kind())
3614 {
3616 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3617 break;
3619 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3620 break;
3622 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3623 break;
3625 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3626 break;
3628 {
3629 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3630 optionValue="";
3631 if (!lst->empty())
3632 {
3633 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3634 static const reg::Ex marker(R"(@(\d+))");
3635 reg::Iterator it(lstFormat,marker);
3636 reg::Iterator end;
3637 size_t index=0;
3638 // now replace all markers with the real text
3639 for ( ; it!=end ; ++it)
3640 {
3641 const auto &match = *it;
3642 size_t newIndex = match.position();
3643 size_t matchLen = match.length();
3644 optionValue += lstFormat.substr(index,newIndex-index);
3645 unsigned long entryIndex = std::stoul(match[1].str());
3646 if (entryIndex<(unsigned long)lst->size())
3647 {
3648 optionValue += lst->at(entryIndex);
3649 }
3650 index=newIndex+matchLen;
3651 }
3652 optionValue+=lstFormat.substr(index);
3653 }
3654 }
3655 break;
3657 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3658 cmdChar,cmdName,parser()->context.token->name);
3659 break;
3661 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3662 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3663 cmdChar,cmdName,parser()->context.token->name);
3664 break;
3666 // nothing to show here
3667 break;
3668 }
3669 if (!optionValue.isEmpty())
3670 {
3671 children().append<DocWord>(parser(),thisVariant(),optionValue);
3672 }
3673 }
3674 else
3675 {
3676 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3677 cmdChar,cmdName,parser()->context.token->name);
3679 }
3681}
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:578
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 3554 of file docnode.cpp.

3555{
3556 AUTO_TRACE();
3557 // get the argument of the emoji command.
3558 Token tok=parser()->tokenizer.lex();
3559 if (!tok.is(TokenRetval::TK_WHITESPACE))
3560 {
3561 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3562 cmdChar,cmdName);
3563 return;
3564 }
3566 tok=parser()->tokenizer.lex();
3567 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3568 {
3569 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3570 "argument of command '{:c}{}'",cmdChar,cmdName);
3572 return;
3573 }
3574 else if (!tok.is(TokenRetval::TK_WORD))
3575 {
3576 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3577 tok.to_string(),cmdChar,cmdName);
3579 return;
3580 }
3583}
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 3872 of file docnode.cpp.

3873{
3874 AUTO_TRACE("cmdName={}",cmdName);
3875 QCString saveCmdName = cmdName;
3876 Token tok=parser()->tokenizer.lex();
3877 if (!tok.is(TokenRetval::TK_WHITESPACE))
3878 {
3879 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3880 saveCmdName);
3881 return;
3882 }
3884 tok=parser()->tokenizer.lex();
3886 if (!tok.is(TokenRetval::TK_WORD))
3887 {
3888 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3889 tok.to_string(),saveCmdName);
3890 return;
3891 }
3892 QCString name = parser()->context.token->name;
3893 children().append<T>(parser(),thisVariant(),name,
3897 auto df = children().get_last<T>();
3898 if (!df->parse())
3899 {
3900 children().pop_back();
3901 }
3902}
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 5429 of file docnode.cpp.

5430{
5431 AUTO_TRACE("tagName={}",tagName);
5432 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5433 Token retval = Token::make_RetVal_OK();
5434 switch (tagId)
5435 {
5437 if (!insideUL(thisVariant()))
5438 {
5439 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5440 }
5441 else
5442 {
5443 retval = Token::make_RetVal_EndList();
5444 }
5445 break;
5447 if (!insideOL(thisVariant()))
5448 {
5449 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5450 }
5451 else
5452 {
5453 retval = Token::make_RetVal_EndList();
5454 }
5455 break;
5457 if (!insideLI(thisVariant()))
5458 {
5459 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5460 }
5461 else
5462 {
5463 // ignore </li> tags
5464 }
5465 break;
5467 if (!insideDetails(thisVariant()))
5468 {
5469 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5470 }
5471 else
5472 {
5473 retval = Token::make_RetVal_EndHtmlDetails();
5474 }
5475 break;
5478 {
5479 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5480 }
5481 else
5482 {
5483 retval = Token::make_RetVal_EndBlockQuote();
5484 }
5485 break;
5488 break;
5491 break;
5494 break;
5497 break;
5500 break;
5503 break;
5506 break;
5509 break;
5512 break;
5515 break;
5518 break;
5521 break;
5524 break;
5527 break;
5530 break;
5533 break;
5536 break;
5541 break;
5543 retval = Token::make_TK_NEWPARA();
5544 break;
5546 retval = Token::make_RetVal_EndDesc();
5547 break;
5549 // ignore </dt> tag
5550 break;
5552 // ignore </dd> tag
5553 break;
5555 retval = Token::make_RetVal_EndTable();
5556 break;
5558 retval = Token::make_RetVal_EndTableRow();
5559 break;
5561 retval = Token::make_RetVal_EndTableCell();
5562 break;
5564 retval = Token::make_RetVal_EndTableCell();
5565 break;
5569 // for time being ignore </t....> tag
5570 break;
5572 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5573 break;
5575 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5576 break;
5578 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5579 break;
5581 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5582 break;
5584 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5585 break;
5587 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5588 break;
5590 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5591 break;
5593 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5594 break;
5596 break;
5598 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5599 break;
5601 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5602 // ignore </a> tag (can be part of <a name=...></a>
5603 break;
5604
5606 break;
5608 retval = Token::make_TK_NEWPARA();
5609 break;
5622 retval = Token::make_RetVal_CloseXml();
5623 break;
5624 case HtmlTagType::XML_C:
5626 break;
5634 // These tags are defined in .Net but are currently unsupported
5635 break;
5637 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5638 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5639 break;
5640 default:
5641 // we should not get here!
5642 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5643 ASSERT(0);
5644 break;
5645 }
5646 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5647 return retval;
5648}
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 4115 of file docnode.cpp.

4116{
4117 AUTO_TRACE();
4118 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4119 Token retval = children().get_last<DocHtmlHeader>()->parse();
4120 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4121}

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

4957{
4958 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4959 Token retval = Token::make_RetVal_OK();
4960 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4961 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4964 {
4965 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4966 tagName);
4967 }
4968 switch (tagId)
4969 {
4971 if (!parser()->context.token->emptyTag)
4972 {
4973 children().append<DocHtmlList>(parser(),thisVariant(),
4974 tagHtmlAttribs,DocHtmlList::Unordered);
4975 retval=children().get_last<DocHtmlList>()->parse();
4976 }
4977 break;
4979 if (!parser()->context.token->emptyTag)
4980 {
4981 children().append<DocHtmlList>(parser(),thisVariant(),
4982 tagHtmlAttribs,DocHtmlList::Ordered);
4983 retval=children().get_last<DocHtmlList>()->parse();
4984 }
4985 break;
4987 if (parser()->context.token->emptyTag) break;
4989 {
4990 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
4991 }
4992 else
4993 {
4994 retval = Token::make_RetVal_ListItem();
4995 }
4996 break;
4998 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
4999 break;
5001 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
5002 break;
5004 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
5005 break;
5007 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
5008 break;
5010 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
5011 break;
5013 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
5014 break;
5016 if (parser()->context.token->emptyTag) break;
5017 if (parser()->context.xmlComment)
5018 // for C# source or inside a <summary> or <remark> section we
5019 // treat <code> as an XML tag (so similar to @code)
5020 {
5022 retval = handleStartCode();
5023 }
5024 else // normal HTML markup
5025 {
5026 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5027 }
5028 break;
5030 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
5031 break;
5033 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
5034 break;
5036 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
5037 break;
5039 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
5040 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5041 break;
5043 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5044 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5045 break;
5047 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5048 break;
5050 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5051 break;
5053 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5054 break;
5056 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5057 break;
5059 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5060 break;
5062 if (parser()->context.token->emptyTag) break;
5063 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5066 break;
5068 retval = Token::make_TK_NEWPARA();
5069 break;
5071 if (!parser()->context.token->emptyTag)
5072 {
5073 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5074 retval=children().get_last<DocHtmlDescList>()->parse();
5075 }
5076 break;
5078 if (insideDL(thisVariant()))
5079 {
5080 retval = Token::make_RetVal_DescTitle();
5081 }
5082 else
5083 {
5084 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5085 }
5086 break;
5088 if (insideDL(thisVariant()))
5089 {
5090 retval = Token::make_RetVal_DescData();
5091 }
5092 else
5093 {
5094 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5095 }
5096 break;
5098 if (!parser()->context.token->emptyTag)
5099 {
5100 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5101 retval=children().get_last<DocHtmlTable>()->parse();
5102 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5103 }
5104 break;
5106 retval = Token::make_RetVal_TableRow();
5107 break;
5109 retval = Token::make_RetVal_TableCell();
5110 break;
5112 retval = Token::make_RetVal_TableHCell();
5113 break;
5117 // for time being ignore </t....> tag
5118 break;
5120 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5121 break;
5123 {
5124 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5125 }
5126 break;
5128 {
5129 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5130 }
5131 break;
5133 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5134 break;
5136 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5137 break;
5139 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5140 break;
5142 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5143 break;
5145 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5146 break;
5148 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5149 break;
5151 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5152 break;
5154 {
5155 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5156 }
5157 break;
5159 if (!parser()->context.token->emptyTag)
5160 {
5161 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5162 retval=children().get_last<DocHtmlDetails>()->parse();
5163 }
5164 break;
5166 if (!parser()->context.token->emptyTag)
5167 {
5168 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5169 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5170 }
5171 break;
5172
5175 {
5176 if (!parser()->context.token->emptyTag)
5177 {
5179 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5180 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5181 if (d)
5182 {
5183 if (!d->summary()) // details section does not have a summary yet
5184 {
5185 d->parseSummary(n,parser()->context.token->attribs);
5186 }
5187 else
5188 {
5189 retval = Token::make_TK_NEWPARA();
5190 }
5191 }
5192 }
5193 }
5194 break;
5198 // fall through
5201 if (!children().empty())
5202 {
5203 retval = Token::make_TK_NEWPARA();
5204 }
5205 break;
5207 if (insideTable(thisVariant()))
5208 {
5209 retval = Token::make_RetVal_TableCell();
5210 }
5211 break;
5212 case HtmlTagType::XML_C:
5213 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5214 break;
5217 {
5219 QCString paramName;
5220 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5221 {
5222 if (paramName.isEmpty())
5223 {
5224 if (Config_getBool(WARN_NO_PARAMDOC))
5225 {
5226 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5227 }
5228 }
5229 else
5230 {
5231 retval = handleParamSection(paramName,
5233 TRUE);
5234 }
5235 }
5236 else
5237 {
5238 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5239 }
5240 }
5241 break;
5244 {
5245 QCString paramName;
5246 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5247 {
5248 //printf("paramName=%s\n",qPrint(paramName));
5249 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5250 children().append<DocWord>(parser(),thisVariant(),paramName);
5251 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5252 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5253 }
5254 else
5255 {
5256 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5257 }
5258 }
5259 break;
5261 {
5263 QCString exceptName;
5264 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5265 {
5266 unescapeCRef(exceptName);
5267 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5268 }
5269 else
5270 {
5271 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5272 }
5273 }
5274 break;
5277 if (insideTable(thisVariant()))
5278 {
5279 retval = Token::make_RetVal_TableRow();
5280 }
5281 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5282 {
5283 retval = Token::make_RetVal_ListItem();
5284 }
5285 else
5286 {
5287 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5288 }
5289 break;
5294 break;
5296 if (insideTable(thisVariant()))
5297 {
5298 retval = Token::make_RetVal_TableCell();
5299 }
5300 break;
5302 // I'm not sure if <see> is the same as <seealso> or if it
5303 // should you link a member without producing a section. The
5304 // C# specification is extremely vague about this (but what else
5305 // can we expect from Microsoft...)
5306 {
5307 QCString cref;
5308 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5309 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5310 {
5311 unescapeCRef(cref);
5312 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5313 {
5314 bool inSeeBlock = parser()->context.inSeeBlock;
5315 parser()->context.token->name = cref;
5318 parser()->context.inSeeBlock = inSeeBlock;
5319 }
5320 else // <see cref="...">...</see> style
5321 {
5322 //DocRef *ref = new DocRef(this,cref);
5323 //children().append(ref);
5324 //ref->parse();
5326 children().append<DocLink>(parser(),thisVariant(),cref);
5327 DocLink *lnk = children().get_last<DocLink>();
5328 QCString leftOver = lnk->parse(FALSE,TRUE);
5329 if (!leftOver.isEmpty())
5330 {
5331 children().append<DocWord>(parser(),thisVariant(),leftOver);
5332 }
5333 }
5334 }
5335 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5336 {
5337 bool inSeeBlock = parser()->context.inSeeBlock;
5338 parser()->context.token->name = cref;
5340 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5342 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5343 parser()->context.inSeeBlock = inSeeBlock;
5344 }
5345 else
5346 {
5347 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5348 }
5349 }
5350 break;
5352 {
5354 QCString cref;
5355 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5356 {
5357 unescapeCRef(cref);
5358 // Look for an existing "see" section
5359 DocNodeVariant *vss=nullptr;
5360 for (auto &n : children())
5361 {
5362 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5363 if (candidate && candidate->type()==DocSimpleSect::See)
5364 {
5365 vss = &n;
5366 }
5367 }
5368
5369 if (!vss) // start new section
5370 {
5371 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5372 vss = &children().back();
5373 }
5374
5375 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5376 retval = Token::make_RetVal_OK();
5377 }
5378 else
5379 {
5380 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5381 }
5382 }
5383 break;
5385 {
5386 QCString type;
5387 findAttribute(tagHtmlAttribs,"type",&type);
5389 HtmlAttribList emptyList;
5390 if (type=="number")
5391 {
5392 listType=DocHtmlList::Ordered;
5393 }
5394 if (type=="table")
5395 {
5396 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5397 retval=children().get_last<DocHtmlTable>()->parseXml();
5398 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5399 }
5400 else
5401 {
5402 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5403 retval=children().get_last<DocHtmlList>()->parseXml();
5404 }
5405 }
5406 break;
5409 // These tags are defined in .Net but are currently unsupported
5411 break;
5413 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5414 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5415 break;
5418 break;
5419 default:
5420 // we should not get here!
5421 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5422 ASSERT(0);
5423 break;
5424 }
5425 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5426 return retval;
5427}
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1492
const DocNodeVariant * summary() const
Definition docnode.h:864
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4115
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:4940
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 3788 of file docnode.cpp.

3789{
3790 AUTO_TRACE();
3791 Token tok=parser()->tokenizer.lex();
3792 if (!tok.is(TokenRetval::TK_WHITESPACE))
3793 {
3794 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3795 cmdChar,cmdName);
3796 return;
3797 }
3799 tok=parser()->tokenizer.lex();
3801 if (!tok.is(TokenRetval::TK_WORD))
3802 {
3803 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3804 tok.to_string(),cmdChar,cmdName);
3805 return;
3806 }
3809}

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

3775{
3776 AUTO_TRACE();
3778 Token tok = parser()->tokenizer.lex();
3779 if (!tok.is(TokenRetval::TK_WORD))
3780 {
3781 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid argument for command '{:c}{}'",
3782 cmdChar,cmdName);
3783 return;
3784 }
3786}
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 3979 of file docnode.cpp.

3980{
3981 AUTO_TRACE("cmdName={}",cmdName);
3982 QCString saveCmdName = cmdName;
3983 Token tok=parser()->tokenizer.lex();
3984 bool isBlock = false;
3985 bool trimLeft = false;
3986 bool localScope = false;
3987 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3988 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3989 {
3991 parser()->tokenizer.lex();
3993 StringVector optList=split(parser()->context.token->name.str(),",");
3994 auto contains = [&optList](const char *kw)
3995 {
3996 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
3997 };
3998 localScope = contains("local");
3999 if (contains("nostrip"))
4000 {
4001 stripCodeComments = false;
4002 }
4003 else if (contains("strip"))
4004 {
4005 stripCodeComments = true;
4006 }
4007 if (t==DocInclude::Snippet && contains("trimleft"))
4008 {
4009 trimLeft = true;
4010 }
4011
4012 if (contains("lineno"))
4013 {
4017 }
4018 tok=parser()->tokenizer.lex();
4019 if (!tok.is(TokenRetval::TK_WHITESPACE))
4020 {
4021 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4022 saveCmdName);
4023 return;
4024 }
4025 }
4026 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
4027 {
4029 parser()->tokenizer.lex();
4030 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
4032 parser()->tokenizer.lex();
4033 }
4034 else if (!tok.is(TokenRetval::TK_WHITESPACE))
4035 {
4036 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
4037 saveCmdName);
4038 return;
4039 }
4041 tok=parser()->tokenizer.lex();
4043 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4044 {
4045 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4046 "argument of command {}",saveCmdName);
4047 return;
4048 }
4049 else if (!tok.is(TokenRetval::TK_WORD))
4050 {
4051 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
4052 tok.to_string(),saveCmdName);
4053 return;
4054 }
4055 QCString fileName = parser()->context.token->name;
4056 QCString blockId;
4058 {
4059 if (fileName == "this") fileName=parser()->context.fileName;
4061 tok=parser()->tokenizer.lex();
4063 if (!tok.is(TokenRetval::TK_WORD))
4064 {
4065 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
4066 tok.to_string(),saveCmdName);
4067 return;
4068 }
4069 blockId = "["+parser()->context.token->name+"]";
4070 }
4071
4072 children().append<DocInclude>(parser(),
4073 thisVariant(),
4074 fileName,
4075 localScope ? parser()->context.context : "",
4076 t,
4077 stripCodeComments,
4080 blockId,isBlock,trimLeft);
4081 children().get_last<DocInclude>()->parse();
4082}
@ 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 3812 of file docnode.cpp.

3813{
3814 AUTO_TRACE("cmdName={}",cmdName);
3815 QCString saveCmdName = cmdName;
3816 Token tok=parser()->tokenizer.lex();
3817 if (!tok.is(TokenRetval::TK_WHITESPACE))
3818 {
3819 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3820 saveCmdName);
3821 return;
3822 }
3824 tok=parser()->tokenizer.lex();
3826 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3827 {
3828 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3829 "argument of command {}", saveCmdName);
3830 return;
3831 }
3832 else if (!tok.is(TokenRetval::TK_WORD))
3833 {
3834 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3835 tok.to_string(),saveCmdName);
3836 return;
3837 }
3838 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3839 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3840 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3841 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3842 //TODO get from context the stripCodeComments()
3843 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3844 children().append<DocIncOperator>(parser(),thisVariant(),t,
3847 stripCodeComments,
3850 );
3851 DocIncOperator *op = children().get_last<DocIncOperator>();
3852 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3853 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3854 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3855 bool isFirst = !n1 || // no last node
3856 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3857 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3858 op->markFirst(isFirst);
3859 op->markLast(true);
3860 if (n1_docIncOp)
3861 {
3862 n1_docIncOp->markLast(false);
3863 }
3864 else if (n1_docWs && n2_docIncOp)
3865 {
3866 n2_docIncOp->markLast(false);
3867 }
3868 op->parse();
3869}
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 4169 of file docnode.cpp.

4170{
4171 if (parser()->context.memberDef) // inheriting docs from a member
4172 {
4173 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4174 if (reMd) // member from which was inherited.
4175 {
4176 const MemberDef *thisMd = parser()->context.memberDef;
4177 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4178 parser()->pushContext();
4179 parser()->context.scope=reMd->getOuterScope();
4180 if (parser()->context.scope!=Doxygen::globalScope)
4181 {
4183 }
4184 parser()->context.memberDef=reMd;
4185 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4186 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4187 parser()->context.copyStack.push_back(reMd);
4190 parser()->context.copyStack.pop_back();
4191 auto hasParamCommand = parser()->context.hasParamCommand;
4192 auto hasReturnCommand = parser()->context.hasReturnCommand;
4193 auto retvalsFound = parser()->context.retvalsFound;
4194 auto paramsFound = parser()->context.paramsFound;
4195 parser()->popContext();
4196 parser()->context.hasParamCommand = hasParamCommand;
4197 parser()->context.hasReturnCommand = hasReturnCommand;
4198 parser()->context.retvalsFound = retvalsFound;
4199 parser()->context.paramsFound = paramsFound;
4200 parser()->context.memberDef = thisMd;
4201 }
4202 }
4203}
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 3911 of file docnode.cpp.

3912{
3913 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3914 QCString saveCmdName = cmdName;
3915 Token tok=parser()->tokenizer.lex();
3916 if (!tok.is(TokenRetval::TK_WHITESPACE))
3917 {
3918 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3919 saveCmdName);
3920 return;
3921 }
3923 tok=parser()->tokenizer.lex();
3924 if (!tok.is(TokenRetval::TK_WORD))
3925 {
3926 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3927 tok.to_string(),saveCmdName);
3928 return;
3929 }
3930 if (saveCmdName == "javalink")
3931 {
3932 children().append<DocStyleChange>(parser(),thisVariant(),
3933 parser()->context.nodeStack.size(),
3934 DocStyleChange::Code,cmdName,TRUE);
3935 }
3938 DocLink *lnk = children().get_last<DocLink>();
3939 if (saveCmdName == "javalink")
3940 {
3941 children().append<DocStyleChange>(parser(),thisVariant(),
3942 parser()->context.nodeStack.size(),
3943 DocStyleChange::Code,cmdName,FALSE);
3944 }
3945 QCString leftOver = lnk->parse(isJavaLink);
3946 if (!leftOver.isEmpty())
3947 {
3948 children().append<DocWord>(parser(),thisVariant(),leftOver);
3949 }
3950}
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 3426 of file docnode.cpp.

3430{
3431 AUTO_TRACE();
3432 DocParamSect *ps = nullptr;
3433 if (!children().empty() && // previous element
3434 (ps=children().get_last<DocParamSect>()) && // was a param sect
3435 ps->type()==t) // of same type
3436 { // append to previous section ps
3437 }
3438 else // start new section
3439 {
3440 children().append<DocParamSect>(parser(),thisVariant(),t);
3441 ps = children().get_last<DocParamSect>();
3442 }
3443 Token rv=ps->parse(cmdName,xmlContext,
3444 static_cast<DocParamSect::Direction>(direction));
3445 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3446 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3447}
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3347
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 3952 of file docnode.cpp.

3953{
3954 AUTO_TRACE("cmdName={}",cmdName);
3955 QCString saveCmdName = cmdName;
3956 Token tok=parser()->tokenizer.lex();
3957 if (!tok.is(TokenRetval::TK_WHITESPACE))
3958 {
3959 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3960 cmdChar,qPrint(saveCmdName));
3961 return;
3962 }
3964 tok=parser()->tokenizer.lex(); // get the reference id
3965 if (!tok.is(TokenRetval::TK_WORD))
3966 {
3967 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3968 tok.to_string(),cmdChar,saveCmdName);
3969 goto endref;
3970 }
3971 children().append<DocRef>(parser(),thisVariant(),
3974 children().get_last<DocRef>()->parse();
3975endref:
3977}
const char * qPrint(const char *s)
Definition qcstring.h:672

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

4085{
4086 AUTO_TRACE("cmdName={}",cmdName);
4087 QCString saveCmdName = cmdName;
4088 // get the argument of the section command.
4089 Token tok=parser()->tokenizer.lex();
4090 if (!tok.is(TokenRetval::TK_WHITESPACE))
4091 {
4092 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4093 cmdChar,saveCmdName);
4094 return;
4095 }
4096 tok=parser()->tokenizer.lex();
4097 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4098 {
4099 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4100 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4101 return;
4102 }
4103 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4104 {
4105 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4106 tok.to_string(),cmdChar,saveCmdName);
4107 return;
4108 }
4111 parser()->tokenizer.lex();
4113}
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 3704 of file docnode.cpp.

3705{
3706 AUTO_TRACE();
3707 QCString fmt;
3708 QCString date;
3709 Token tok=parser()->tokenizer.lex();
3710 if (!tok.is(TokenRetval::TK_WHITESPACE))
3711 {
3712 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3713 cmdChar,cmdName);
3714 return;
3715 }
3717 tok = parser()->tokenizer.lex();
3718 if (!tok.is(TokenRetval::TK_WORD))
3719 {
3720 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3721 cmdChar,cmdName);
3723 return;
3724 }
3725 fmt = parser()->context.token->name;
3726
3728 tok = parser()->tokenizer.lex();
3729
3730 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3731 QCString specDate = specDateRaw.stripWhiteSpace();
3732 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3733 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3734 {
3735 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3736 cmdChar,cmdName);
3738 return;
3739 }
3740
3741 std::tm dat{};
3742 int specFormat=0;
3743 QCString err = dateTimeFromString(specDate,dat,specFormat);
3744 if (!err.isEmpty())
3745 {
3746 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3747 cmdChar,cmdName,err);
3749 return;
3750 }
3751
3752 int usedFormat=0;
3753 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3754
3755 // warn the user if the format contains markers that are not explicitly filled in
3756 for (int i=0;i<SF_NumBits;i++)
3757 {
3758 int bitMask = 1<<i;
3759 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3760 {
3761 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.",
3762 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3763 }
3764 }
3765
3766 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3767 if (specDateOnlyWS) // specDate is only whitespace
3768 {
3769 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3770 }
3772}
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 3396 of file docnode.cpp.

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

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

4134{
4135 AUTO_TRACE();
4136 Token retval = parser()->tokenizer.lex();
4137 QCString lang = parser()->context.token->name;
4138 if (!lang.isEmpty() && lang.at(0)!='.')
4139 {
4140 lang="."+lang;
4141 }
4142 if (parser()->context.xmlComment)
4143 {
4144 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4145 }
4146 // search for the first non-whitespace line, index is stored in li
4147 size_t i=0,li=0,l=parser()->context.token->verb.length();
4148 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4149 {
4150 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4151 i++;
4152 }
4153 children().append<DocVerbatim>(parser(),thisVariant(),
4155 stripIndentation(parser()->context.token->verb.mid(li)),
4159 FALSE,lang);
4160 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4161 {
4162 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4163 }
4165 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4166 return retval;
4167}
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:477
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 3904 of file docnode.cpp.

3905{
3906 AUTO_TRACE();
3907 children().append<DocVhdlFlow>(parser(),thisVariant());
3908 children().get_last<DocVhdlFlow>()->parse();
3909}

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

3684{
3685 AUTO_TRACE();
3686 Token retval=parser()->tokenizer.lex();
3687 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3689 retval=parser()->tokenizer.lex();
3690 if (retval.is(TokenRetval::RetVal_OK))
3691 {
3692 children().append<DocXRefItem>(parser(),thisVariant(),
3694 DocXRefItem *ref = children().get_last<DocXRefItem>();
3695 if (!ref->parse())
3696 {
3697 children().pop_back();
3698 }
3699 }
3701 return retval;
3702}
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 4126 of file docnode.cpp.

4127{
4128 AUTO_TRACE();
4129 parser()->context.token->name = tokText;
4130 return parser()->defaultHandleToken(thisVariant(),tok,children());
4131}
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 5702 of file docnode.cpp.

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