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

3349 :
3352{
3353}
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 3408 of file docnode.cpp.

3409{
3410 AUTO_TRACE();
3411 QCString saveCmdName = cmdName;
3412 // get the argument of the cite command.
3413 Token tok=parser()->tokenizer.lex();
3414
3415 CiteInfoOption option;
3416 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3417 {
3419 parser()->tokenizer.lex();
3420 StringVector optList=split(parser()->context.token->name.str(),",");
3421 for (auto const &opt : optList)
3422 {
3423 if (opt == "number")
3424 {
3425 if (!option.isUnknown())
3426 {
3427 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3428 }
3429 else
3430 {
3431 option = CiteInfoOption::makeNumber();
3432 }
3433 }
3434 else if (opt == "year")
3435 {
3436 if (!option.isUnknown())
3437 {
3438 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3439 }
3440 else
3441 {
3442 option = CiteInfoOption::makeYear();
3443 }
3444 }
3445 else if (opt == "shortauthor")
3446 {
3447 if (!option.isUnknown())
3448 {
3449 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3450 }
3451 else
3452 {
3454 }
3455 }
3456 else if (opt == "nopar")
3457 {
3458 option.setNoPar();
3459 }
3460 else if (opt == "nocite")
3461 {
3462 option.setNoCite();
3463 }
3464 else
3465 {
3466 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unknown option specified with \\{}, discarding '{}'", saveCmdName, opt);
3467 }
3468 }
3469
3470 if (option.isUnknown()) option.changeToNumber();
3471
3473 tok=parser()->tokenizer.lex();
3474 if (!tok.is(TokenRetval::TK_WHITESPACE))
3475 {
3476 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3477 saveCmdName);
3478 return;
3479 }
3480 }
3481 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3482 {
3483 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3484 cmdChar,saveCmdName);
3485 return;
3486 }
3487 else
3488 {
3489 option = CiteInfoOption::makeNumber();
3490 }
3491
3493 tok=parser()->tokenizer.lex();
3494 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3495 {
3496 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"THE ONE unexpected end of comment block while parsing the "
3497 "argument of command '{:c}{}'",cmdChar,saveCmdName);
3498 return;
3499 }
3500 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3501 {
3502 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3503 tok.to_string(),cmdChar,saveCmdName);
3504 return;
3505 }
3507 children().append<DocCite>(
3509
3511}
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:92
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:7129

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

4166{
4167 AUTO_TRACE("cmdName={}",cmdName);
4168 Token retval = Token::make_RetVal_OK();
4169 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
4170 switch (cmdId)
4171 {
4173 {
4174 std::string str{cmdChar};
4175 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
4176 if (isAliasCmd(cmdName.view()))
4177 {
4178 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
4179 }
4180 else
4181 {
4182 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4183 }
4184 }
4185 break;
4187 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,TRUE);
4188 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4189 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,FALSE);
4190 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4191 break;
4193 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,TRUE);
4194 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4195 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,FALSE);
4196 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4197 break;
4199 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,TRUE);
4200 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4201 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,FALSE);
4202 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4203 break;
4206 break;
4209 break;
4212 break;
4215 break;
4218 break;
4221 break;
4224 break;
4227 break;
4230 break;
4233 break;
4237 break;
4242 break;
4245 break;
4248 break;
4251 break;
4254 break;
4257 break;
4260 break;
4263 break;
4268 break;
4272 break;
4275 break;
4278 break;
4281 break;
4284 break;
4287 break;
4290 break;
4293 break;
4296 break;
4299 break;
4302 break;
4305 break;
4308 break;
4311 break;
4314 break;
4317 break;
4319 {
4320 children().append<DocSimpleList>(parser(),thisVariant());
4321 retval = children().get_last<DocSimpleList>()->parse();
4322 }
4323 break;
4325 {
4326 handleSection(cmdChar,cmdName);
4327 retval = Token::make_RetVal_Section();
4328 }
4329 break;
4331 {
4332 handleSection(cmdChar,cmdName);
4333 retval = Token::make_RetVal_Subsection();
4334 }
4335 break;
4337 {
4338 handleSection(cmdChar,cmdName);
4339 retval = Token::make_RetVal_Subsubsection();
4340 }
4341 break;
4343 {
4344 handleSection(cmdChar,cmdName);
4345 retval = Token::make_RetVal_Paragraph();
4346 }
4347 break;
4349 {
4350 handleSection(cmdChar,cmdName);
4351 retval = Token::make_RetVal_SubParagraph();
4352 }
4353 break;
4355 {
4356 handleSection(cmdChar,cmdName);
4357 retval = Token::make_RetVal_SubSubParagraph();
4358 }
4359 break;
4361 {
4363 retval = handleStartCode();
4364 }
4365 break;
4367 {
4369 retval = handleStartCode();
4370 }
4371 break;
4373 {
4375 retval = parser()->tokenizer.lex();
4377 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4378 {
4379 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4380 }
4382 }
4383 break;
4385 {
4387 retval = parser()->tokenizer.lex();
4389 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4390 {
4391 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4392 }
4394 }
4395 break;
4397 {
4399 retval = parser()->tokenizer.lex();
4401 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4402 {
4403 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4404 }
4406 }
4407 break;
4409 {
4411 retval = parser()->tokenizer.lex();
4413 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4414 {
4415 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4416 }
4418 }
4419 break;
4421 {
4423 retval = parser()->tokenizer.lex();
4425 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4426 {
4427 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4428 }
4430 }
4431 break;
4433 {
4435 retval = parser()->tokenizer.lex();
4437 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4438 {
4439 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4440 }
4442 }
4443 break;
4445 {
4448 parser()->tokenizer.lex();
4449
4450 QCString fullMatch = parser()->context.token->verb;
4451 int idx = fullMatch.find('{');
4452 int idxEnd = fullMatch.find("}",idx+1);
4453 StringVector optList;
4454 if (idx != -1) // options present
4455 {
4456 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4457 optList = split(optStr.str(),",");
4458 for (const auto &opt : optList)
4459 {
4460 if (opt.empty()) continue;
4461 QCString locOpt(opt);
4462 locOpt = locOpt.stripWhiteSpace().lower();
4463 if (locOpt == "code")
4464 {
4466 }
4467 else if (!locOpt.isEmpty())
4468 {
4469 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4470 }
4471 }
4472 }
4473
4475 retval = parser()->tokenizer.lex();
4477 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4478 {
4479 if (t == DocVerbatim::JavaDocCode)
4480 {
4481 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4482 }
4483 else
4484 {
4485 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4486 }
4487 }
4489 }
4490 break;
4493 {
4494 if (cmdId == CommandType::CMD_VERBATIM)
4495 {
4497 }
4498 else
4499 {
4501 }
4502 retval = parser()->tokenizer.lex();
4504 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4505 {
4506 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4507 }
4509 }
4510 break;
4512 {
4513 children().append<DocVerbatim>(parser(),thisVariant(),
4519 DocVerbatim *dv = children().get_last<DocVerbatim>();
4521 QCString width,height;
4522 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4524 retval = parser()->tokenizer.lex();
4525 dv->setText(parser()->context.token->verb);
4526 dv->setWidth(width);
4527 dv->setHeight(height);
4528 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4529 if (!Config_getBool(HAVE_DOT))
4530 {
4531 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4532 children().pop_back();
4533 }
4534 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4535 {
4536 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4537 }
4539 }
4540 break;
4542 {
4543 children().append<DocVerbatim>(parser(),thisVariant(),
4549 DocVerbatim *dv = children().get_last<DocVerbatim>();
4551 QCString width,height;
4552 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4554 retval = parser()->tokenizer.lex();
4555 dv->setText(parser()->context.token->verb);
4556 dv->setWidth(width);
4557 dv->setHeight(height);
4558 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4559 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4560 {
4561 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4562 }
4564 }
4565 break;
4567 {
4568 QCString jarPath = Config_getString(PLANTUML_JAR_PATH);
4570 parser()->tokenizer.lex();
4571 QCString fullMatch = parser()->context.token->sectionId;
4572 QCString sectionId = "";
4573 int idx = fullMatch.find('{');
4574 int idxEnd = fullMatch.find("}",idx+1);
4575 StringVector optList;
4576 QCString engine;
4577 if (idx != -1) // options present
4578 {
4579 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4580 optList = split(optStr.str(),",");
4581 for (const auto &opt : optList)
4582 {
4583 if (opt.empty()) continue;
4584 bool found = false;
4585 QCString locOpt(opt);
4586 locOpt = locOpt.stripWhiteSpace().lower();
4587 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4588 {
4589 if (!engine.isEmpty())
4590 {
4591 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4592 }
4593 engine = locOpt;
4594 found = true;
4595 }
4596 if (!found)
4597 {
4598 if (sectionId.isEmpty())
4599 {
4600 sectionId = opt;
4601 }
4602 else
4603 {
4604 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4605 }
4606 }
4607 }
4608 }
4609 else
4610 {
4611 sectionId = parser()->context.token->sectionId;
4612 }
4613 if (engine.isEmpty()) engine = "uml";
4614
4615 if (sectionId.isEmpty())
4616 {
4618 retval = parser()->tokenizer.lex();
4619 assert(retval.is(TokenRetval::RetVal_OK));
4620
4621 sectionId = parser()->context.token->sectionId;
4622 sectionId = sectionId.stripWhiteSpace();
4623 }
4624
4625 QCString plantFile(sectionId);
4626 children().append<DocVerbatim>(parser(),thisVariant(),
4630 FALSE,plantFile);
4631 DocVerbatim *dv = children().get_last<DocVerbatim>();
4632 dv->setEngine(engine);
4634 QCString width,height;
4635 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4637 retval = parser()->tokenizer.lex();
4638 int line = 0;
4639 QCString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4640 if (engine == "ditaa")
4641 {
4642 dv->setUseBitmap(true);
4643 }
4644 else if (engine == "uml")
4645 {
4646 int i = trimmedVerb.find('\n');
4647 QCString firstLine = i==-1 ? trimmedVerb : trimmedVerb.left(i);
4648 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4649 }
4650 dv->setText(trimmedVerb);
4651 dv->setWidth(width);
4652 dv->setHeight(height);
4653 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4654 if (jarPath.isEmpty())
4655 {
4656 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because PLANTUML_JAR_PATH is not set");
4657 children().pop_back();
4658 }
4659 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4660 {
4661 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4662 }
4664 }
4665 break;
4667 retval = Token::make_RetVal_EndParBlock();
4668 break;
4684 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4685 break;
4687 retval = handleParamSection(cmdName,DocParamSect::Param,FALSE,parser()->context.token->paramDir);
4688 break;
4690 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,FALSE,parser()->context.token->paramDir);
4691 break;
4693 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4694 break;
4697 break;
4699 retval = handleXRefItem();
4700 break;
4702 {
4703 children().append<DocLineBreak>(parser(),thisVariant());
4704 }
4705 break;
4708 {
4710 }
4711 break;
4713 {
4715 }
4716 break;
4718 {
4719 children().append<DocIndexEntry>(parser(),thisVariant(),
4722 retval = children().get_last<DocIndexEntry>()->parse();
4723 }
4724 break;
4726 retval = Token::make_RetVal_Internal();
4727 break;
4729 retval = Token::make_RetVal_EndInternal();
4730 break;
4732 {
4733 children().append<DocParBlock>(parser(),thisVariant());
4734 retval = children().get_last<DocParBlock>()->parse();
4735 }
4736 break;
4737 case CommandType::CMD_COPYDOC: // fall through
4738 case CommandType::CMD_COPYBRIEF: // fall through
4740 //retval = Token::make_RetVal_CopyDoc();
4741 // these commands should already be resolved by processCopyDoc()
4742 break;
4745 break;
4748 break;
4751 break;
4754 break;
4757 break;
4760 break;
4763 break;
4766 break;
4769 break;
4772 break;
4775 break;
4778 break;
4781 break;
4784 break;
4787 break;
4790 break;
4793 break;
4795 if (!Config_getBool(HAVE_DOT))
4796 {
4797 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4798 "ignoring \\dotfile command because HAVE_DOT is not set");
4799 }
4800 else
4801 {
4802 handleFile<DocDotFile>(cmdName);
4803 }
4804 break;
4807 break;
4809 handleFile<DocMscFile>(cmdName);
4810 break;
4812 handleFile<DocDiaFile>(cmdName);
4813 break;
4816 break;
4818 handleLink(cmdName,FALSE);
4819 break;
4821 handleLink(cmdName,TRUE);
4822 break;
4824 handleCite(cmdChar,cmdName);
4825 break;
4827 handleEmoji(cmdChar,cmdName);
4828 break;
4830 handleDoxyConfig(cmdChar,cmdName);
4831 break;
4832 case CommandType::CMD_REF: // fall through
4834 handleRef(cmdChar,cmdName);
4835 break;
4837 {
4838 children().append<DocSecRefList>(parser(),thisVariant());
4839 children().get_last<DocSecRefList>()->parse();
4840 }
4841 break;
4843 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4844 break;
4846 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4847 break;
4849 {
4850 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4851 }
4852 break;
4853 //case CommandType::CMD_LANGSWITCH:
4854 // retval = handleLanguageSwitch();
4855 // break;
4857 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4858 {
4861 }
4862 break;
4865 break;
4867 handleShowDate(cmdChar,cmdName);
4868 break;
4870 handleILine(cmdChar,cmdName);
4871 break;
4873 handleIFile(cmdChar,cmdName);
4874 break;
4876 {
4878 (void)parser()->tokenizer.lex();
4880 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
4882 }
4883 break;
4884 default:
4885 // we should not get here!
4886 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
4887 break;
4888 }
4889 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
4890 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
4891 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
4892 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
4893 TokenRetval::RetVal_EndInternal)
4894 );
4895 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4896 return retval;
4897}
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:3355
void handleLink(const QCString &cmdName, bool isJavaLink)
Definition docnode.cpp:3870
void handleInheritDoc()
Definition docnode.cpp:4128
void handleCite(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3408
void handleInclude(const QCString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3938
void handleDoxyConfig(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3544
void handleSection(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4043
void handleFile(const QCString &cmdName)
Definition docnode.cpp:3831
void handleIFile(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3747
Token handleParamSection(const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3385
void handleEmoji(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3513
void handleIncludeOperator(const QCString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3771
void handleRef(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3911
void handleILine(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3733
Token parse()
Definition docnode.cpp:5661
void handleVhdlFlow()
Definition docnode.cpp:3863
void handleShowDate(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3663
Token handleXRefItem()
Definition docnode.cpp:3642
Token handleStartCode()
Definition docnode.cpp:4092
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
int line
Definition htmlgen.cpp:159
size_t i
Definition htmlgen.cpp:161
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:66
QCString exampleName
Definition docparser_p.h:79
const Definition * scope
Definition docparser_p.h:61
const MemberDef * memberDef
Definition docparser_p.h:77
QCString verb
QCString stripLeadingAndTrailingEmptyLines(const QCString &s, int &docLine)
Special version of QCString::stripWhiteSpace() that only strips completely blank lines.
Definition util.cpp:5537

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, i, 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, 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 3544 of file docnode.cpp.

3545{
3546 // get the argument of the cite command.
3547 Token tok=parser()->tokenizer.lex();
3548 if (!tok.is(TokenRetval::TK_WHITESPACE))
3549 {
3550 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3551 cmdChar,cmdName);
3552 return;
3553 }
3555 tok=parser()->tokenizer.lex();
3556 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3557 {
3558 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3559 "argument of command '{:c}{}'",cmdChar,cmdName);
3560 return;
3561 }
3562 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3563 {
3564 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3565 tok.to_string(),cmdChar,cmdName);
3566 return;
3567 }
3568 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3569 if (opt)
3570 {
3571 QCString optionValue;
3572 switch (opt->kind())
3573 {
3575 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3576 break;
3578 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3579 break;
3581 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3582 break;
3584 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3585 break;
3587 {
3588 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3589 optionValue="";
3590 if (!lst->empty())
3591 {
3592 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3593 static const reg::Ex marker(R"(@(\d+))");
3594 reg::Iterator it(lstFormat,marker);
3595 reg::Iterator end;
3596 size_t index=0;
3597 // now replace all markers with the real text
3598 for ( ; it!=end ; ++it)
3599 {
3600 const auto &match = *it;
3601 size_t newIndex = match.position();
3602 size_t matchLen = match.length();
3603 optionValue += lstFormat.substr(index,newIndex-index);
3604 unsigned long entryIndex = std::stoul(match[1].str());
3605 if (entryIndex<(unsigned long)lst->size())
3606 {
3607 optionValue += lst->at(entryIndex);
3608 }
3609 index=newIndex+matchLen;
3610 }
3611 optionValue+=lstFormat.substr(index);
3612 }
3613 }
3614 break;
3616 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3617 cmdChar,cmdName,parser()->context.token->name);
3618 break;
3620 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3621 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3622 cmdChar,cmdName,parser()->context.token->name);
3623 break;
3625 // nothing to show here
3626 break;
3627 }
3628 if (!optionValue.isEmpty())
3629 {
3630 children().append<DocWord>(parser(),thisVariant(),optionValue);
3631 }
3632 }
3633 else
3634 {
3635 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3636 cmdChar,cmdName,parser()->context.token->name);
3638 }
3640}
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 3513 of file docnode.cpp.

3514{
3515 AUTO_TRACE();
3516 // get the argument of the emoji command.
3517 Token tok=parser()->tokenizer.lex();
3518 if (!tok.is(TokenRetval::TK_WHITESPACE))
3519 {
3520 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3521 cmdChar,cmdName);
3522 return;
3523 }
3525 tok=parser()->tokenizer.lex();
3526 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3527 {
3528 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3529 "argument of command '{:c}{}'",cmdChar,cmdName);
3531 return;
3532 }
3533 else if (!tok.is(TokenRetval::TK_WORD))
3534 {
3535 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3536 tok.to_string(),cmdChar,cmdName);
3538 return;
3539 }
3542}
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 3831 of file docnode.cpp.

3832{
3833 AUTO_TRACE("cmdName={}",cmdName);
3834 QCString saveCmdName = cmdName;
3835 Token tok=parser()->tokenizer.lex();
3836 if (!tok.is(TokenRetval::TK_WHITESPACE))
3837 {
3838 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3839 saveCmdName);
3840 return;
3841 }
3843 tok=parser()->tokenizer.lex();
3845 if (!tok.is(TokenRetval::TK_WORD))
3846 {
3847 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3848 tok.to_string(),saveCmdName);
3849 return;
3850 }
3851 QCString name = parser()->context.token->name;
3852 children().append<T>(parser(),thisVariant(),name,
3856 auto df = children().get_last<T>();
3857 if (!df->parse())
3858 {
3859 children().pop_back();
3860 }
3861}
void setStateFile()
int getLineNr(void)
QCString fileName
Definition docparser_p.h:70

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

5389{
5390 AUTO_TRACE("tagName={}",tagName);
5391 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5392 Token retval = Token::make_RetVal_OK();
5393 switch (tagId)
5394 {
5396 if (!insideUL(thisVariant()))
5397 {
5398 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5399 }
5400 else
5401 {
5402 retval = Token::make_RetVal_EndList();
5403 }
5404 break;
5406 if (!insideOL(thisVariant()))
5407 {
5408 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5409 }
5410 else
5411 {
5412 retval = Token::make_RetVal_EndList();
5413 }
5414 break;
5416 if (!insideLI(thisVariant()))
5417 {
5418 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5419 }
5420 else
5421 {
5422 // ignore </li> tags
5423 }
5424 break;
5426 if (!insideDetails(thisVariant()))
5427 {
5428 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5429 }
5430 else
5431 {
5432 retval = Token::make_RetVal_EndHtmlDetails();
5433 }
5434 break;
5437 {
5438 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5439 }
5440 else
5441 {
5442 retval = Token::make_RetVal_EndBlockQuote();
5443 }
5444 break;
5447 break;
5450 break;
5453 break;
5456 break;
5459 break;
5462 break;
5465 break;
5468 break;
5471 break;
5474 break;
5477 break;
5480 break;
5483 break;
5486 break;
5489 break;
5492 break;
5495 break;
5500 break;
5502 retval = Token::make_TK_NEWPARA();
5503 break;
5505 retval = Token::make_RetVal_EndDesc();
5506 break;
5508 // ignore </dt> tag
5509 break;
5511 // ignore </dd> tag
5512 break;
5514 retval = Token::make_RetVal_EndTable();
5515 break;
5517 retval = Token::make_RetVal_EndTableRow();
5518 break;
5520 retval = Token::make_RetVal_EndTableCell();
5521 break;
5523 retval = Token::make_RetVal_EndTableCell();
5524 break;
5528 // for time being ignore </t....> tag
5529 break;
5531 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5532 break;
5534 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5535 break;
5537 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5538 break;
5540 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5541 break;
5543 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5544 break;
5546 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5547 break;
5549 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5550 break;
5552 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5553 break;
5555 break;
5557 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5558 break;
5560 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5561 // ignore </a> tag (can be part of <a name=...></a>
5562 break;
5563
5565 break;
5567 retval = Token::make_TK_NEWPARA();
5568 break;
5581 retval = Token::make_RetVal_CloseXml();
5582 break;
5583 case HtmlTagType::XML_C:
5585 break;
5593 // These tags are defined in .Net but are currently unsupported
5594 break;
5596 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5597 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5598 break;
5599 default:
5600 // we should not get here!
5601 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5602 ASSERT(0);
5603 break;
5604 }
5605 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5606 return retval;
5607}
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 4074 of file docnode.cpp.

4075{
4076 AUTO_TRACE();
4077 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4078 Token retval = children().get_last<DocHtmlHeader>()->parse();
4079 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4080}

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

4916{
4917 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4918 Token retval = Token::make_RetVal_OK();
4919 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4920 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4923 {
4924 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4925 tagName);
4926 }
4927 switch (tagId)
4928 {
4930 if (!parser()->context.token->emptyTag)
4931 {
4932 children().append<DocHtmlList>(parser(),thisVariant(),
4933 tagHtmlAttribs,DocHtmlList::Unordered);
4934 retval=children().get_last<DocHtmlList>()->parse();
4935 }
4936 break;
4938 if (!parser()->context.token->emptyTag)
4939 {
4940 children().append<DocHtmlList>(parser(),thisVariant(),
4941 tagHtmlAttribs,DocHtmlList::Ordered);
4942 retval=children().get_last<DocHtmlList>()->parse();
4943 }
4944 break;
4946 if (parser()->context.token->emptyTag) break;
4948 {
4949 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
4950 }
4951 else
4952 {
4953 retval = Token::make_RetVal_ListItem();
4954 }
4955 break;
4957 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
4958 break;
4960 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
4961 break;
4963 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
4964 break;
4966 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
4967 break;
4969 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
4970 break;
4972 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
4973 break;
4975 if (parser()->context.token->emptyTag) break;
4976 if (parser()->context.xmlComment)
4977 // for C# source or inside a <summary> or <remark> section we
4978 // treat <code> as an XML tag (so similar to @code)
4979 {
4981 retval = handleStartCode();
4982 }
4983 else // normal HTML markup
4984 {
4985 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
4986 }
4987 break;
4989 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
4990 break;
4992 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
4993 break;
4995 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
4996 break;
4998 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
4999 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5000 break;
5002 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5003 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5004 break;
5006 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5007 break;
5009 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5010 break;
5012 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5013 break;
5015 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5016 break;
5018 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5019 break;
5021 if (parser()->context.token->emptyTag) break;
5022 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5025 break;
5027 retval = Token::make_TK_NEWPARA();
5028 break;
5030 if (!parser()->context.token->emptyTag)
5031 {
5032 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5033 retval=children().get_last<DocHtmlDescList>()->parse();
5034 }
5035 break;
5037 if (insideDL(thisVariant()))
5038 {
5039 retval = Token::make_RetVal_DescTitle();
5040 }
5041 else
5042 {
5043 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5044 }
5045 break;
5047 if (insideDL(thisVariant()))
5048 {
5049 retval = Token::make_RetVal_DescData();
5050 }
5051 else
5052 {
5053 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5054 }
5055 break;
5057 if (!parser()->context.token->emptyTag)
5058 {
5059 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5060 retval=children().get_last<DocHtmlTable>()->parse();
5061 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5062 }
5063 break;
5065 retval = Token::make_RetVal_TableRow();
5066 break;
5068 retval = Token::make_RetVal_TableCell();
5069 break;
5071 retval = Token::make_RetVal_TableHCell();
5072 break;
5076 // for time being ignore </t....> tag
5077 break;
5079 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5080 break;
5082 {
5083 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5084 }
5085 break;
5087 {
5088 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5089 }
5090 break;
5092 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5093 break;
5095 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5096 break;
5098 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5099 break;
5101 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5102 break;
5104 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5105 break;
5107 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5108 break;
5110 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5111 break;
5113 {
5114 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5115 }
5116 break;
5118 if (!parser()->context.token->emptyTag)
5119 {
5120 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5121 retval=children().get_last<DocHtmlDetails>()->parse();
5122 }
5123 break;
5125 if (!parser()->context.token->emptyTag)
5126 {
5127 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5128 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5129 }
5130 break;
5131
5134 {
5135 if (!parser()->context.token->emptyTag)
5136 {
5138 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5139 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5140 if (d)
5141 {
5142 if (!d->summary()) // details section does not have a summary yet
5143 {
5144 d->parseSummary(n,parser()->context.token->attribs);
5145 }
5146 else
5147 {
5148 retval = Token::make_TK_NEWPARA();
5149 }
5150 }
5151 }
5152 }
5153 break;
5157 // fall through
5160 if (!children().empty())
5161 {
5162 retval = Token::make_TK_NEWPARA();
5163 }
5164 break;
5166 if (insideTable(thisVariant()))
5167 {
5168 retval = Token::make_RetVal_TableCell();
5169 }
5170 break;
5171 case HtmlTagType::XML_C:
5172 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5173 break;
5176 {
5178 QCString paramName;
5179 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5180 {
5181 if (paramName.isEmpty())
5182 {
5183 if (Config_getBool(WARN_NO_PARAMDOC))
5184 {
5185 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5186 }
5187 }
5188 else
5189 {
5190 retval = handleParamSection(paramName,
5192 TRUE);
5193 }
5194 }
5195 else
5196 {
5197 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5198 }
5199 }
5200 break;
5203 {
5204 QCString paramName;
5205 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5206 {
5207 //printf("paramName=%s\n",qPrint(paramName));
5208 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5209 children().append<DocWord>(parser(),thisVariant(),paramName);
5210 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5211 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5212 }
5213 else
5214 {
5215 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5216 }
5217 }
5218 break;
5220 {
5222 QCString exceptName;
5223 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5224 {
5225 unescapeCRef(exceptName);
5226 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5227 }
5228 else
5229 {
5230 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5231 }
5232 }
5233 break;
5236 if (insideTable(thisVariant()))
5237 {
5238 retval = Token::make_RetVal_TableRow();
5239 }
5240 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5241 {
5242 retval = Token::make_RetVal_ListItem();
5243 }
5244 else
5245 {
5246 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5247 }
5248 break;
5253 break;
5255 if (insideTable(thisVariant()))
5256 {
5257 retval = Token::make_RetVal_TableCell();
5258 }
5259 break;
5261 // I'm not sure if <see> is the same as <seealso> or if it
5262 // should you link a member without producing a section. The
5263 // C# specification is extremely vague about this (but what else
5264 // can we expect from Microsoft...)
5265 {
5266 QCString cref;
5267 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5268 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5269 {
5270 unescapeCRef(cref);
5271 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5272 {
5273 bool inSeeBlock = parser()->context.inSeeBlock;
5274 parser()->context.token->name = cref;
5277 parser()->context.inSeeBlock = inSeeBlock;
5278 }
5279 else // <see cref="...">...</see> style
5280 {
5281 //DocRef *ref = new DocRef(this,cref);
5282 //children().append(ref);
5283 //ref->parse();
5285 children().append<DocLink>(parser(),thisVariant(),cref);
5286 DocLink *lnk = children().get_last<DocLink>();
5287 QCString leftOver = lnk->parse(FALSE,TRUE);
5288 if (!leftOver.isEmpty())
5289 {
5290 children().append<DocWord>(parser(),thisVariant(),leftOver);
5291 }
5292 }
5293 }
5294 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5295 {
5296 bool inSeeBlock = parser()->context.inSeeBlock;
5297 parser()->context.token->name = cref;
5299 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5301 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5302 parser()->context.inSeeBlock = inSeeBlock;
5303 }
5304 else
5305 {
5306 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5307 }
5308 }
5309 break;
5311 {
5313 QCString cref;
5314 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5315 {
5316 unescapeCRef(cref);
5317 // Look for an existing "see" section
5318 DocNodeVariant *vss=nullptr;
5319 for (auto &n : children())
5320 {
5321 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5322 if (candidate && candidate->type()==DocSimpleSect::See)
5323 {
5324 vss = &n;
5325 }
5326 }
5327
5328 if (!vss) // start new section
5329 {
5330 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5331 vss = &children().back();
5332 }
5333
5334 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5335 retval = Token::make_RetVal_OK();
5336 }
5337 else
5338 {
5339 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5340 }
5341 }
5342 break;
5344 {
5345 QCString type;
5346 findAttribute(tagHtmlAttribs,"type",&type);
5348 HtmlAttribList emptyList;
5349 if (type=="number")
5350 {
5351 listType=DocHtmlList::Ordered;
5352 }
5353 if (type=="table")
5354 {
5355 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5356 retval=children().get_last<DocHtmlTable>()->parseXml();
5357 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5358 }
5359 else
5360 {
5361 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5362 retval=children().get_last<DocHtmlList>()->parseXml();
5363 }
5364 }
5365 break;
5368 // These tags are defined in .Net but are currently unsupported
5370 break;
5372 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5373 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5374 break;
5377 break;
5378 default:
5379 // we should not get here!
5380 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5381 ASSERT(0);
5382 break;
5383 }
5384 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5385 return retval;
5386}
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1480
const DocNodeVariant * summary() const
Definition docnode.h:864
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4074
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:4899
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 3747 of file docnode.cpp.

3748{
3749 AUTO_TRACE();
3750 Token tok=parser()->tokenizer.lex();
3751 if (!tok.is(TokenRetval::TK_WHITESPACE))
3752 {
3753 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3754 cmdChar,cmdName);
3755 return;
3756 }
3758 tok=parser()->tokenizer.lex();
3760 if (!tok.is(TokenRetval::TK_WORD))
3761 {
3762 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3763 tok.to_string(),cmdChar,cmdName);
3764 return;
3765 }
3768}

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

3734{
3735 AUTO_TRACE();
3737 Token tok = parser()->tokenizer.lex();
3738 if (!tok.is(TokenRetval::TK_WORD))
3739 {
3740 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid argument for command '{:c}{}'",
3741 cmdChar,cmdName);
3742 return;
3743 }
3745}
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 3938 of file docnode.cpp.

3939{
3940 AUTO_TRACE("cmdName={}",cmdName);
3941 QCString saveCmdName = cmdName;
3942 Token tok=parser()->tokenizer.lex();
3943 bool isBlock = false;
3944 bool trimLeft = false;
3945 bool localScope = false;
3946 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3947 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3948 {
3950 parser()->tokenizer.lex();
3952 StringVector optList=split(parser()->context.token->name.str(),",");
3953 auto contains = [&optList](const char *kw)
3954 {
3955 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
3956 };
3957 localScope = contains("local");
3958 if (contains("nostrip"))
3959 {
3960 stripCodeComments = false;
3961 }
3962 else if (contains("strip"))
3963 {
3964 stripCodeComments = true;
3965 }
3966 if (t==DocInclude::Snippet && contains("trimleft"))
3967 {
3968 trimLeft = true;
3969 }
3970
3971 if (contains("lineno"))
3972 {
3976 }
3977 tok=parser()->tokenizer.lex();
3978 if (!tok.is(TokenRetval::TK_WHITESPACE))
3979 {
3980 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3981 saveCmdName);
3982 return;
3983 }
3984 }
3985 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
3986 {
3988 parser()->tokenizer.lex();
3989 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
3991 parser()->tokenizer.lex();
3992 }
3993 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3994 {
3995 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3996 saveCmdName);
3997 return;
3998 }
4000 tok=parser()->tokenizer.lex();
4002 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4003 {
4004 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4005 "argument of command {}",saveCmdName);
4006 return;
4007 }
4008 else if (!tok.is(TokenRetval::TK_WORD))
4009 {
4010 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
4011 tok.to_string(),saveCmdName);
4012 return;
4013 }
4014 QCString fileName = parser()->context.token->name;
4015 QCString blockId;
4017 {
4018 if (fileName == "this") fileName=parser()->context.fileName;
4020 tok=parser()->tokenizer.lex();
4022 if (!tok.is(TokenRetval::TK_WORD))
4023 {
4024 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
4025 tok.to_string(),saveCmdName);
4026 return;
4027 }
4028 blockId = "["+parser()->context.token->name+"]";
4029 }
4030
4031 children().append<DocInclude>(parser(),
4032 thisVariant(),
4033 fileName,
4034 localScope ? parser()->context.context : "",
4035 t,
4036 stripCodeComments,
4039 blockId,isBlock,trimLeft);
4040 children().get_last<DocInclude>()->parse();
4041}
@ 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 3771 of file docnode.cpp.

3772{
3773 AUTO_TRACE("cmdName={}",cmdName);
3774 QCString saveCmdName = cmdName;
3775 Token tok=parser()->tokenizer.lex();
3776 if (!tok.is(TokenRetval::TK_WHITESPACE))
3777 {
3778 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3779 saveCmdName);
3780 return;
3781 }
3783 tok=parser()->tokenizer.lex();
3785 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3786 {
3787 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3788 "argument of command {}", saveCmdName);
3789 return;
3790 }
3791 else if (!tok.is(TokenRetval::TK_WORD))
3792 {
3793 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3794 tok.to_string(),saveCmdName);
3795 return;
3796 }
3797 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3798 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3799 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3800 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3801 //TODO get from context the stripCodeComments()
3802 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3803 children().append<DocIncOperator>(parser(),thisVariant(),t,
3806 stripCodeComments,
3809 );
3810 DocIncOperator *op = children().get_last<DocIncOperator>();
3811 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3812 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3813 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3814 bool isFirst = !n1 || // no last node
3815 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3816 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3817 op->markFirst(isFirst);
3818 op->markLast(true);
3819 if (n1_docIncOp)
3820 {
3821 n1_docIncOp->markLast(false);
3822 }
3823 else if (n1_docWs && n2_docIncOp)
3824 {
3825 n2_docIncOp->markLast(false);
3826 }
3827 op->parse();
3828}
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 4128 of file docnode.cpp.

4129{
4130 if (parser()->context.memberDef) // inheriting docs from a member
4131 {
4132 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4133 if (reMd) // member from which was inherited.
4134 {
4135 const MemberDef *thisMd = parser()->context.memberDef;
4136 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4137 parser()->pushContext();
4138 parser()->context.scope=reMd->getOuterScope();
4139 if (parser()->context.scope!=Doxygen::globalScope)
4140 {
4142 }
4143 parser()->context.memberDef=reMd;
4144 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4145 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4146 parser()->context.copyStack.push_back(reMd);
4149 parser()->context.copyStack.pop_back();
4150 auto hasParamCommand = parser()->context.hasParamCommand;
4151 auto hasReturnCommand = parser()->context.hasReturnCommand;
4152 auto retvalsFound = parser()->context.retvalsFound;
4153 auto paramsFound = parser()->context.paramsFound;
4154 parser()->popContext();
4155 parser()->context.hasParamCommand = hasParamCommand;
4156 parser()->context.hasReturnCommand = hasReturnCommand;
4157 parser()->context.retvalsFound = retvalsFound;
4158 parser()->context.paramsFound = paramsFound;
4159 parser()->context.memberDef = thisMd;
4160 }
4161 }
4162}
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:75
DocStyleChangeStack styleStack
Definition docparser_p.h:67
StringMultiSet paramsFound
Definition docparser_p.h:76
DefinitionStack copyStack
Definition docparser_p.h:69

References Definition::briefDescription(), DocCompoundNode::children(), DocParser::context, DocParserContext::context, DocParserContext::copyStack, Definition::documentation(), Definition::getOuterScope(), Doxygen::globalScope, DocParserContext::hasParamCommand, DocParserContext::hasReturnCommand, DocParser::internalValidatingParseDoc(), DocParserContext::memberDef, Definition::name(), DocParserContext::nodeStack, DocParserContext::paramsFound, DocNode::parser(), 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 3870 of file docnode.cpp.

3871{
3872 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3873 QCString saveCmdName = cmdName;
3874 Token tok=parser()->tokenizer.lex();
3875 if (!tok.is(TokenRetval::TK_WHITESPACE))
3876 {
3877 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3878 saveCmdName);
3879 return;
3880 }
3882 tok=parser()->tokenizer.lex();
3883 if (!tok.is(TokenRetval::TK_WORD))
3884 {
3885 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3886 tok.to_string(),saveCmdName);
3887 return;
3888 }
3889 if (saveCmdName == "javalink")
3890 {
3891 children().append<DocStyleChange>(parser(),thisVariant(),
3892 parser()->context.nodeStack.size(),
3893 DocStyleChange::Code,cmdName,TRUE);
3894 }
3897 DocLink *lnk = children().get_last<DocLink>();
3898 if (saveCmdName == "javalink")
3899 {
3900 children().append<DocStyleChange>(parser(),thisVariant(),
3901 parser()->context.nodeStack.size(),
3902 DocStyleChange::Code,cmdName,FALSE);
3903 }
3904 QCString leftOver = lnk->parse(isJavaLink);
3905 if (!leftOver.isEmpty())
3906 {
3907 children().append<DocWord>(parser(),thisVariant(),leftOver);
3908 }
3909}
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 3385 of file docnode.cpp.

3389{
3390 AUTO_TRACE();
3391 DocParamSect *ps = nullptr;
3392 if (!children().empty() && // previous element
3393 (ps=children().get_last<DocParamSect>()) && // was a param sect
3394 ps->type()==t) // of same type
3395 { // append to previous section ps
3396 }
3397 else // start new section
3398 {
3399 children().append<DocParamSect>(parser(),thisVariant(),t);
3400 ps = children().get_last<DocParamSect>();
3401 }
3402 Token rv=ps->parse(cmdName,xmlContext,
3403 static_cast<DocParamSect::Direction>(direction));
3404 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3405 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3406}
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3306
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 3911 of file docnode.cpp.

3912{
3913 AUTO_TRACE("cmdName={}",cmdName);
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 '{:c}{}' command",
3919 cmdChar,qPrint(saveCmdName));
3920 return;
3921 }
3923 tok=parser()->tokenizer.lex(); // get the reference id
3924 if (!tok.is(TokenRetval::TK_WORD))
3925 {
3926 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3927 tok.to_string(),cmdChar,saveCmdName);
3928 goto endref;
3929 }
3930 children().append<DocRef>(parser(),thisVariant(),
3933 children().get_last<DocRef>()->parse();
3934endref:
3936}
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 4043 of file docnode.cpp.

4044{
4045 AUTO_TRACE("cmdName={}",cmdName);
4046 QCString saveCmdName = cmdName;
4047 // get the argument of the section command.
4048 Token tok=parser()->tokenizer.lex();
4049 if (!tok.is(TokenRetval::TK_WHITESPACE))
4050 {
4051 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4052 cmdChar,saveCmdName);
4053 return;
4054 }
4055 tok=parser()->tokenizer.lex();
4056 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4057 {
4058 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4059 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4060 return;
4061 }
4062 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4063 {
4064 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4065 tok.to_string(),cmdChar,saveCmdName);
4066 return;
4067 }
4070 parser()->tokenizer.lex();
4072}
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 3663 of file docnode.cpp.

3664{
3665 AUTO_TRACE();
3666 QCString fmt;
3667 QCString date;
3668 Token tok=parser()->tokenizer.lex();
3669 if (!tok.is(TokenRetval::TK_WHITESPACE))
3670 {
3671 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3672 cmdChar,cmdName);
3673 return;
3674 }
3676 tok = parser()->tokenizer.lex();
3677 if (!tok.is(TokenRetval::TK_WORD))
3678 {
3679 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3680 cmdChar,cmdName);
3682 return;
3683 }
3684 fmt = parser()->context.token->name;
3685
3687 tok = parser()->tokenizer.lex();
3688
3689 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3690 QCString specDate = specDateRaw.stripWhiteSpace();
3691 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3692 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3693 {
3694 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3695 cmdChar,cmdName);
3697 return;
3698 }
3699
3700 std::tm dat{};
3701 int specFormat=0;
3702 QCString err = dateTimeFromString(specDate,dat,specFormat);
3703 if (!err.isEmpty())
3704 {
3705 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3706 cmdChar,cmdName,err);
3708 return;
3709 }
3710
3711 int usedFormat=0;
3712 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3713
3714 // warn the user if the format contains markers that are not explicitly filled in
3715 for (int i=0;i<SF_NumBits;i++)
3716 {
3717 int bitMask = 1<<i;
3718 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3719 {
3720 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.",
3721 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3722 }
3723 }
3724
3725 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3726 if (specDateOnlyWS) // specDate is only whitespace
3727 {
3728 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3729 }
3731}
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(), i, 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 3355 of file docnode.cpp.

3356{
3357 AUTO_TRACE();
3358 DocSimpleSect *ss=nullptr;
3359 bool needsSeparator = FALSE;
3360 if (!children().empty() && // has previous element
3361 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3362 ss->type()==t && // of same type
3363 t!=DocSimpleSect::User) // but not user defined
3364 {
3365 // append to previous section
3366 needsSeparator = TRUE;
3367 }
3368 else // start new section
3369 {
3370 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3371 ss = children().get_last<DocSimpleSect>();
3372 }
3373 Token rv = Token::make_RetVal_OK();
3374 if (xmlContext)
3375 {
3376 return ss->parseXml();
3377 }
3378 else
3379 {
3380 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3381 }
3382 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3383}
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3020
Token parseXml()
Definition docnode.cpp:3074

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

4093{
4094 AUTO_TRACE();
4095 Token retval = parser()->tokenizer.lex();
4096 QCString lang = parser()->context.token->name;
4097 if (!lang.isEmpty() && lang.at(0)!='.')
4098 {
4099 lang="."+lang;
4100 }
4101 if (parser()->context.xmlComment)
4102 {
4103 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4104 }
4105 // search for the first non-whitespace line, index is stored in li
4106 size_t i=0,li=0,l=parser()->context.token->verb.length();
4107 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4108 {
4109 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4110 i++;
4111 }
4112 children().append<DocVerbatim>(parser(),thisVariant(),
4114 stripIndentation(parser()->context.token->verb.mid(li)),
4118 FALSE,lang);
4119 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4120 {
4121 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4122 }
4124 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4125 return retval;
4126}
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:6462

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

3864{
3865 AUTO_TRACE();
3866 children().append<DocVhdlFlow>(parser(),thisVariant());
3867 children().get_last<DocVhdlFlow>()->parse();
3868}

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

3643{
3644 AUTO_TRACE();
3645 Token retval=parser()->tokenizer.lex();
3646 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3648 retval=parser()->tokenizer.lex();
3649 if (retval.is(TokenRetval::RetVal_OK))
3650 {
3651 children().append<DocXRefItem>(parser(),thisVariant(),
3653 DocXRefItem *ref = children().get_last<DocXRefItem>();
3654 if (!ref->parse())
3655 {
3656 children().pop_back();
3657 }
3658 }
3660 return retval;
3661}
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 4085 of file docnode.cpp.

4086{
4087 AUTO_TRACE();
4088 parser()->context.token->name = tokText;
4089 return parser()->defaultHandleToken(thisVariant(),tok,children());
4090}
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 5661 of file docnode.cpp.

5662{
5663 AUTO_TRACE();
5664 auto ns = AutoNodeStack(parser(),thisVariant());
5665 // handle style commands "inherited" from the previous paragraph
5667 Token tok=parser()->tokenizer.lex();
5668 Token retval = Token::make_TK_NONE();
5669 while (!tok.is_any_of(TokenRetval::TK_NONE, TokenRetval::TK_EOF)) // get the next token
5670 {
5671reparsetoken:
5672 AUTO_TRACE_ADD("token '{}' at {}",tok.to_string(),parser()->tokenizer.getLineNr());
5673 if (tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD,TokenRetval::TK_SYMBOL,TokenRetval::TK_URL,
5674 TokenRetval::TK_COMMAND_AT,TokenRetval::TK_COMMAND_BS,TokenRetval::TK_HTMLTAG)
5675 )
5676 {
5677 AUTO_TRACE_ADD("name={}",parser()->context.token->name);
5678 }
5679 switch(tok.value())
5680 {
5681 case TokenRetval::TK_WORD:
5683 break;
5684 case TokenRetval::TK_LNKWORD:
5686 break;
5687 case TokenRetval::TK_URL:
5689 break;
5690 case TokenRetval::TK_WHITESPACE:
5691 {
5692 // prevent leading whitespace and collapse multiple whitespace areas
5693 if (insidePRE(thisVariant()) || // all whitespace is relevant
5694 (
5695 // remove leading whitespace
5696 !children().empty() &&
5697 // and whitespace after certain constructs
5698 !holds_one_of_alternatives<DocHtmlDescList, DocHtmlTable, DocHtmlList, DocSimpleSect,
5699 DocAutoList, DocSimpleList, DocHtmlHeader, DocHtmlBlockQuote,
5700 DocParamSect, DocHtmlDetails, DocXRefItem>(children().back())
5701 )
5702 )
5703 {
5704 children().append<DocWhiteSpace>(parser(),thisVariant(),parser()->context.token->chars);
5705 }
5706 }
5707 break;
5708 case TokenRetval::TK_LISTITEM:
5709 {
5710 AUTO_TRACE_ADD("found list item at {}",parser()->context.token->indent);
5711 const DocNodeVariant *n=parent();
5712 while (n && !std::holds_alternative<DocAutoList>(*n)) n=::parent(n);
5713 const DocAutoList *al = std::get_if<DocAutoList>(n);
5714 if (al) // we found an auto list up in the hierarchy
5715 {
5716 AUTO_TRACE_ADD("previous list item at {}",al->indent());
5717 if (al->indent()>=parser()->context.token->indent)
5718 // new item at the same or lower indent level
5719 {
5720 retval = Token::make_TK_LISTITEM();
5721 goto endparagraph;
5722 }
5723 }
5724
5725 // determine list depth
5726 int depth = 0;
5727 n=parent();
5728 while (n)
5729 {
5730 al = std::get_if<DocAutoList>(n);
5731 if (al && al->isEnumList()) depth++;
5732 n=::parent(n);
5733 }
5734
5735 // first item or sub list => create new list
5736 do
5737 {
5738 children().append<DocAutoList>(parser(),thisVariant(),
5740 parser()->context.token->isEnumList,depth,
5742 al = children().get_last<DocAutoList>();
5743 retval = children().get_last<DocAutoList>()->parse();
5744 } while (retval.is(TokenRetval::TK_LISTITEM) && // new list
5745 al->indent()==parser()->context.token->indent // at same indent level
5746 );
5747
5748 // check the return value
5749 if (retval.is(TokenRetval::RetVal_SimpleSec)) // auto list ended due to simple section command
5750 {
5751 // Reparse the token that ended the section at this level,
5752 // so a new simple section will be started at this level.
5753 // This is the same as unputting the last read token and continuing.
5755 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5756 {
5759 tok = Token::make_TK_RCSTAG();
5760 }
5761 else // other section
5762 {
5763 tok = Token::make_TK_COMMAND_BS();
5764 }
5765 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5766 goto reparsetoken;
5767 }
5768 else if (retval.is(TokenRetval::TK_ENDLIST))
5769 {
5770 if (al->indent()>parser()->context.token->indent) // end list
5771 {
5772 goto endparagraph;
5773 }
5774 else // continue with current paragraph
5775 {
5776 }
5777 }
5778 else // paragraph ended due to TokenRetval::TK_NEWPARA, TokenRetval::TK_LISTITEM, or EOF
5779 {
5780 goto endparagraph;
5781 }
5782 }
5783 break;
5784 case TokenRetval::TK_ENDLIST:
5785 AUTO_TRACE_ADD("Found end of list inside of paragraph at line {}",parser()->tokenizer.getLineNr());
5786 if (std::get_if<DocAutoListItem>(parent()))
5787 {
5788 const DocAutoList *al = std::get_if<DocAutoList>(::parent(parent()));
5789 if (al && al->indent()>=parser()->context.token->indent)
5790 {
5791 // end of list marker ends this paragraph
5792 retval = Token::make_TK_ENDLIST();
5793 goto endparagraph;
5794 }
5795 else
5796 {
5797 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found "
5798 "has invalid indent level");
5799 }
5800 }
5801 else
5802 {
5803 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found without any preceding "
5804 "list items");
5805 }
5806 break;
5807 case TokenRetval::TK_COMMAND_AT:
5808 // fall through
5809 case TokenRetval::TK_COMMAND_BS:
5810 {
5811 // see if we have to start a simple section
5812 CommandType cmd = Mappers::cmdMapper->map(parser()->context.token->name);
5813 const DocNodeVariant *n=parent();
5814 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5815 !std::holds_alternative<DocParamSect>(*n))
5816 {
5817 n=::parent(n);
5818 }
5820 {
5821 if (n) // already in a simple section
5822 {
5823 // simple section cannot start in this paragraph, need
5824 // to unwind the stack and remember the command.
5826 retval = Token::make_RetVal_SimpleSec();
5827 goto endparagraph;
5828 }
5829 }
5830 // see if we are in a simple list
5831 n=parent();
5832 while (n && !std::holds_alternative<DocSimpleListItem>(*n)) n=::parent(n);
5833 if (n)
5834 {
5835 if (cmd==CommandType::CMD_LI)
5836 {
5837 retval = Token::make_RetVal_ListItem();
5838 goto endparagraph;
5839 }
5840 }
5841
5842 // handle the command
5843 retval=handleCommand(tok.command_to_char(),parser()->context.token->name);
5844 AUTO_TRACE_ADD("handleCommand returns {}",retval.to_string());
5845
5846 // check the return value
5847 if (retval.is(TokenRetval::RetVal_SimpleSec))
5848 {
5849 // Reparse the token that ended the section at this level,
5850 // so a new simple section will be started at this level.
5851 // This is the same as unputting the last read token and continuing.
5853 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5854 {
5857 tok = Token::make_TK_RCSTAG();
5858 }
5859 else // other section
5860 {
5861 tok = Token::make_TK_COMMAND_BS();
5862 }
5863 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5864 goto reparsetoken;
5865 }
5866 else if (retval.value()>TokenRetval::TK_NONE && retval.value()<TokenRetval::RetVal_OK)
5867 {
5868 // the command ended with a new command, reparse this token
5869 tok = retval;
5870 goto reparsetoken;
5871 }
5872 else if (retval.value()!=TokenRetval::RetVal_OK) // end of file, end of paragraph, start or end of section
5873 // or some auto list marker
5874 {
5875 goto endparagraph;
5876 }
5877 }
5878 break;
5879 case TokenRetval::TK_HTMLTAG:
5880 {
5881 if (!parser()->context.token->endTag) // found a start tag
5882 {
5883 retval = handleHtmlStartTag(parser()->context.token->name,parser()->context.token->attribs);
5884 }
5885 else // found an end tag
5886 {
5888 {
5889 break; // new code has been pushed back to the scanner, need to reparse
5890 }
5891 retval = handleHtmlEndTag(parser()->context.token->name);
5892 }
5893 if (!retval.is(TokenRetval::RetVal_OK))
5894 {
5895 goto endparagraph;
5896 }
5897 }
5898 break;
5899 case TokenRetval::TK_SYMBOL:
5900 {
5903 {
5904 children().append<DocSymbol>(parser(),thisVariant(),s);
5905 }
5906 else
5907 {
5909 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported symbol '{}' found",
5910 parser()->context.token->name);
5911 }
5912 break;
5913 }
5914 case TokenRetval::TK_NEWPARA:
5915 retval = Token::make_TK_NEWPARA();
5916 goto endparagraph;
5917 case TokenRetval::TK_RCSTAG:
5918 {
5919 const DocNodeVariant *n=parent();
5920 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5921 !std::holds_alternative<DocParamSect>(*n))
5922 {
5923 n=::parent(n);
5924 }
5925 if (n) // already in a simple section
5926 {
5927 // simple section cannot start in this paragraph, need
5928 // to unwind the stack and remember the command.
5931 retval = Token::make_RetVal_SimpleSec();
5932 goto endparagraph;
5933 }
5934
5935 // see if we are in a simple list
5936 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::Rcs);
5937 children().get_last<DocSimpleSect>()->parseRcs();
5938 }
5939 break;
5940 default:
5941 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
5942 "Found unexpected token (id={})",tok.to_string());
5943 break;
5944 }
5945 tok=parser()->tokenizer.lex();
5946 }
5947 retval=Token::make_TK_NONE();
5948endparagraph:
5950 DocPara *par = std::get_if<DocPara>(parser()->context.nodeStack.top());
5951 if (!parser()->context.token->endTag && par &&
5952 retval.is(TokenRetval::TK_NEWPARA) && parser()->context.token->name.lower() == "p")
5953 {
5954 par->setAttribs(parser()->context.token->attribs);
5955 }
5956 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::TK_NEWPARA,TokenRetval::TK_LISTITEM,
5957 TokenRetval::TK_ENDLIST,TokenRetval::RetVal_OK)
5958 );
5959
5960 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5961 return retval;
5962}
bool isEnumList() const
Definition docnode.h:580
int indent() const
Definition docnode.h:581
DocPara(DocParser *parser, DocNodeVariant *parent)
Definition docnode.cpp:3349
Token handleCommand(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4165
Token handleHtmlStartTag(const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Definition docnode.cpp:4915
void setAttribs(const HtmlAttribList &attribs)
Definition docnode.h:1115
Token handleHtmlEndTag(const QCString &tagName)
Definition docnode.cpp:5388
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:5609
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)
QCString s
Definition htmlgen.cpp:154
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, s, 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: