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

3348 :
3351{
3352}
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 3407 of file docnode.cpp.

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

4165{
4166 AUTO_TRACE("cmdName={}",cmdName);
4167 Token retval = Token::make_RetVal_OK();
4168 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
4169 switch (cmdId)
4170 {
4172 {
4173 std::string str{cmdChar};
4174 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
4175 if (isAliasCmd(cmdName.view()))
4176 {
4177 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
4178 }
4179 else
4180 {
4181 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4182 }
4183 }
4184 break;
4186 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,TRUE);
4187 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4188 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,FALSE);
4189 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4190 break;
4192 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,TRUE);
4193 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4194 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,FALSE);
4195 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4196 break;
4198 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,TRUE);
4199 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4200 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,FALSE);
4201 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4202 break;
4205 break;
4208 break;
4211 break;
4214 break;
4217 break;
4220 break;
4223 break;
4226 break;
4229 break;
4232 break;
4236 break;
4241 break;
4244 break;
4247 break;
4250 break;
4253 break;
4256 break;
4259 break;
4262 break;
4267 break;
4271 break;
4274 break;
4277 break;
4280 break;
4283 break;
4286 break;
4289 break;
4292 break;
4295 break;
4298 break;
4301 break;
4304 break;
4307 break;
4310 break;
4313 break;
4316 break;
4318 {
4319 children().append<DocSimpleList>(parser(),thisVariant());
4320 retval = children().get_last<DocSimpleList>()->parse();
4321 }
4322 break;
4324 {
4325 handleSection(cmdChar,cmdName);
4326 retval = Token::make_RetVal_Section();
4327 }
4328 break;
4330 {
4331 handleSection(cmdChar,cmdName);
4332 retval = Token::make_RetVal_Subsection();
4333 }
4334 break;
4336 {
4337 handleSection(cmdChar,cmdName);
4338 retval = Token::make_RetVal_Subsubsection();
4339 }
4340 break;
4342 {
4343 handleSection(cmdChar,cmdName);
4344 retval = Token::make_RetVal_Paragraph();
4345 }
4346 break;
4348 {
4349 handleSection(cmdChar,cmdName);
4350 retval = Token::make_RetVal_SubParagraph();
4351 }
4352 break;
4354 {
4355 handleSection(cmdChar,cmdName);
4356 retval = Token::make_RetVal_SubSubParagraph();
4357 }
4358 break;
4360 {
4362 retval = handleStartCode();
4363 }
4364 break;
4366 {
4368 retval = handleStartCode();
4369 }
4370 break;
4372 {
4374 retval = parser()->tokenizer.lex();
4376 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4377 {
4378 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4379 }
4381 }
4382 break;
4384 {
4386 retval = parser()->tokenizer.lex();
4388 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4389 {
4390 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4391 }
4393 }
4394 break;
4396 {
4398 retval = parser()->tokenizer.lex();
4400 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4401 {
4402 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4403 }
4405 }
4406 break;
4408 {
4410 retval = parser()->tokenizer.lex();
4412 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4413 {
4414 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4415 }
4417 }
4418 break;
4420 {
4422 retval = parser()->tokenizer.lex();
4424 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4425 {
4426 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4427 }
4429 }
4430 break;
4432 {
4434 retval = parser()->tokenizer.lex();
4436 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4437 {
4438 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4439 }
4441 }
4442 break;
4444 {
4447 parser()->tokenizer.lex();
4448
4449 QCString fullMatch = parser()->context.token->verb;
4450 int idx = fullMatch.find('{');
4451 int idxEnd = fullMatch.find("}",idx+1);
4452 StringVector optList;
4453 if (idx != -1) // options present
4454 {
4455 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4456 optList = split(optStr.str(),",");
4457 for (const auto &opt : optList)
4458 {
4459 if (opt.empty()) continue;
4460 QCString locOpt(opt);
4461 locOpt = locOpt.stripWhiteSpace().lower();
4462 if (locOpt == "code")
4463 {
4465 }
4466 else if (!locOpt.isEmpty())
4467 {
4468 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4469 }
4470 }
4471 }
4472
4474 retval = parser()->tokenizer.lex();
4476 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4477 {
4478 if (t == DocVerbatim::JavaDocCode)
4479 {
4480 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4481 }
4482 else
4483 {
4484 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4485 }
4486 }
4488 }
4489 break;
4492 {
4493 if (cmdId == CommandType::CMD_VERBATIM)
4494 {
4496 }
4497 else
4498 {
4500 }
4501 retval = parser()->tokenizer.lex();
4503 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4504 {
4505 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4506 }
4508 }
4509 break;
4511 {
4512 children().append<DocVerbatim>(parser(),thisVariant(),
4518 DocVerbatim *dv = children().get_last<DocVerbatim>();
4520 QCString width,height;
4521 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4523 retval = parser()->tokenizer.lex();
4524 dv->setText(parser()->context.token->verb);
4525 dv->setWidth(width);
4526 dv->setHeight(height);
4527 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4528 if (!Config_getBool(HAVE_DOT))
4529 {
4530 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4531 children().pop_back();
4532 }
4533 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4534 {
4535 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4536 }
4538 }
4539 break;
4541 {
4542 children().append<DocVerbatim>(parser(),thisVariant(),
4548 DocVerbatim *dv = children().get_last<DocVerbatim>();
4550 QCString width,height;
4551 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4553 retval = parser()->tokenizer.lex();
4554 dv->setText(parser()->context.token->verb);
4555 dv->setWidth(width);
4556 dv->setHeight(height);
4557 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4558 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4559 {
4560 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4561 }
4563 }
4564 break;
4566 {
4567 QCString jarPath = Config_getString(PLANTUML_JAR_PATH);
4569 parser()->tokenizer.lex();
4570 QCString fullMatch = parser()->context.token->sectionId;
4571 QCString sectionId = "";
4572 int idx = fullMatch.find('{');
4573 int idxEnd = fullMatch.find("}",idx+1);
4574 StringVector optList;
4575 QCString engine;
4576 if (idx != -1) // options present
4577 {
4578 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4579 optList = split(optStr.str(),",");
4580 for (const auto &opt : optList)
4581 {
4582 if (opt.empty()) continue;
4583 bool found = false;
4584 QCString locOpt(opt);
4585 locOpt = locOpt.stripWhiteSpace().lower();
4586 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4587 {
4588 if (!engine.isEmpty())
4589 {
4590 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4591 }
4592 engine = locOpt;
4593 found = true;
4594 }
4595 if (!found)
4596 {
4597 if (sectionId.isEmpty())
4598 {
4599 sectionId = opt;
4600 }
4601 else
4602 {
4603 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4604 }
4605 }
4606 }
4607 }
4608 else
4609 {
4610 sectionId = parser()->context.token->sectionId;
4611 }
4612 if (engine.isEmpty()) engine = "uml";
4613
4614 if (sectionId.isEmpty())
4615 {
4617 retval = parser()->tokenizer.lex();
4618 assert(retval.is(TokenRetval::RetVal_OK));
4619
4620 sectionId = parser()->context.token->sectionId;
4621 sectionId = sectionId.stripWhiteSpace();
4622 }
4623
4624 QCString plantFile(sectionId);
4625 children().append<DocVerbatim>(parser(),thisVariant(),
4629 FALSE,plantFile);
4630 DocVerbatim *dv = children().get_last<DocVerbatim>();
4631 dv->setEngine(engine);
4633 QCString width,height;
4634 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4636 retval = parser()->tokenizer.lex();
4637 int line = 0;
4638 QCString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4639 if (engine == "ditaa")
4640 {
4641 dv->setUseBitmap(true);
4642 }
4643 else if (engine == "uml")
4644 {
4645 int i = trimmedVerb.find('\n');
4646 QCString firstLine = i==-1 ? trimmedVerb : trimmedVerb.left(i);
4647 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4648 }
4649 dv->setText(trimmedVerb);
4650 dv->setWidth(width);
4651 dv->setHeight(height);
4652 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4653 if (jarPath.isEmpty())
4654 {
4655 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because PLANTUML_JAR_PATH is not set");
4656 children().pop_back();
4657 }
4658 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4659 {
4660 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4661 }
4663 }
4664 break;
4666 retval = Token::make_RetVal_EndParBlock();
4667 break;
4683 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4684 break;
4686 retval = handleParamSection(cmdName,DocParamSect::Param,FALSE,parser()->context.token->paramDir);
4687 break;
4689 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,FALSE,parser()->context.token->paramDir);
4690 break;
4692 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4693 break;
4696 break;
4698 retval = handleXRefItem();
4699 break;
4701 {
4702 children().append<DocLineBreak>(parser(),thisVariant());
4703 }
4704 break;
4707 {
4709 }
4710 break;
4712 {
4714 }
4715 break;
4717 {
4718 children().append<DocIndexEntry>(parser(),thisVariant(),
4721 retval = children().get_last<DocIndexEntry>()->parse();
4722 }
4723 break;
4725 retval = Token::make_RetVal_Internal();
4726 break;
4728 retval = Token::make_RetVal_EndInternal();
4729 break;
4731 {
4732 children().append<DocParBlock>(parser(),thisVariant());
4733 retval = children().get_last<DocParBlock>()->parse();
4734 }
4735 break;
4736 case CommandType::CMD_COPYDOC: // fall through
4737 case CommandType::CMD_COPYBRIEF: // fall through
4739 //retval = Token::make_RetVal_CopyDoc();
4740 // these commands should already be resolved by processCopyDoc()
4741 break;
4744 break;
4747 break;
4750 break;
4753 break;
4756 break;
4759 break;
4762 break;
4765 break;
4768 break;
4771 break;
4774 break;
4777 break;
4780 break;
4783 break;
4786 break;
4789 break;
4792 break;
4794 if (!Config_getBool(HAVE_DOT))
4795 {
4796 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4797 "ignoring \\dotfile command because HAVE_DOT is not set");
4798 }
4799 else
4800 {
4801 handleFile<DocDotFile>(cmdName);
4802 }
4803 break;
4806 break;
4808 handleFile<DocMscFile>(cmdName);
4809 break;
4811 handleFile<DocDiaFile>(cmdName);
4812 break;
4815 break;
4817 handleLink(cmdName,FALSE);
4818 break;
4820 handleLink(cmdName,TRUE);
4821 break;
4823 handleCite(cmdChar,cmdName);
4824 break;
4826 handleEmoji(cmdChar,cmdName);
4827 break;
4829 handleDoxyConfig(cmdChar,cmdName);
4830 break;
4831 case CommandType::CMD_REF: // fall through
4833 handleRef(cmdChar,cmdName);
4834 break;
4836 {
4837 children().append<DocSecRefList>(parser(),thisVariant());
4838 children().get_last<DocSecRefList>()->parse();
4839 }
4840 break;
4842 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4843 break;
4845 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4846 break;
4848 {
4849 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4850 }
4851 break;
4852 //case CommandType::CMD_LANGSWITCH:
4853 // retval = handleLanguageSwitch();
4854 // break;
4856 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4857 {
4860 }
4861 break;
4864 break;
4866 handleShowDate(cmdChar,cmdName);
4867 break;
4869 handleILine(cmdChar,cmdName);
4870 break;
4872 handleIFile(cmdChar,cmdName);
4873 break;
4875 {
4877 (void)parser()->tokenizer.lex();
4879 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
4881 }
4882 break;
4883 default:
4884 // we should not get here!
4885 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
4886 break;
4887 }
4888 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
4889 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
4890 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
4891 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
4892 TokenRetval::RetVal_EndInternal)
4893 );
4894 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4895 return retval;
4896}
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:3354
void handleLink(const QCString &cmdName, bool isJavaLink)
Definition docnode.cpp:3869
void handleInheritDoc()
Definition docnode.cpp:4127
void handleCite(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3407
void handleInclude(const QCString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3937
void handleDoxyConfig(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3543
void handleSection(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:4042
void handleFile(const QCString &cmdName)
Definition docnode.cpp:3830
void handleIFile(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3746
Token handleParamSection(const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3384
void handleEmoji(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3512
void handleIncludeOperator(const QCString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3770
void handleRef(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3910
void handleILine(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3732
Token parse()
Definition docnode.cpp:5660
void handleVhdlFlow()
Definition docnode.cpp:3862
void handleShowDate(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3662
Token handleXRefItem()
Definition docnode.cpp:3641
Token handleStartCode()
Definition docnode.cpp:4091
void handleInternalRef(DocNodeVariant *parent, DocNodeList &children)
void handleImage(DocNodeVariant *parent, DocNodeList &children)
void handlePrefix(DocNodeVariant *parent, DocNodeList &children)
Token handleStyleArgument(DocNodeVariant *parent, DocNodeList &children, const QCString &cmdName)
void handleAnchor(DocNodeVariant *parent, DocNodeList &children)
void defaultHandleTitleAndSize(const CommandType cmd, DocNodeVariant *parent, DocNodeList &children, QCString &width, QCString &height)
void setStateILiteralOpt()
void setStateILiteral()
void setStateCode()
void setStatePlantUMLOpt()
void setStateRtfOnly()
void setStateVerbatim()
void setStateLatexOnly()
void setStateManOnly()
void setStateDbOnly()
void setStateHtmlOnly()
void setStateICode()
void setStatePlantUML()
void setStateIVerbatim()
void setStateXmlOnly()
void setStateSetScope()
@ JavaDocLiteral
Definition docnode.h:378
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
void pop_back()
removes the last element
Definition growvector.h:115
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:226
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:150
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:245
const std::string & str() const
Definition qcstring.h:537
std::string_view view() const
Definition qcstring.h:161
QCString left(size_t len) const
Definition qcstring.h:214
CommandType
Definition cmdmapper.h:29
@ CMD_ENDSECREFLIST
Definition cmdmapper.h:53
@ CMD_ENDLATEXONLY
Definition cmdmapper.h:51
@ CMD_ENDVERBATIM
Definition cmdmapper.h:54
@ CMD_DONTINCLUDE
Definition cmdmapper.h:46
@ CMD_SUBSUBSECTION
Definition cmdmapper.h:89
@ CMD_SUBSUBPARAGRAPH
Definition cmdmapper.h:161
@ CMD_INTERNALREF
Definition cmdmapper.h:65
@ CMD_ENDHTMLONLY
Definition cmdmapper.h:50
@ CMD_VERBINCLUDE
Definition cmdmapper.h:98
@ CMD_DOCBOOKINCLUDE
Definition cmdmapper.h:145
@ CMD_HTMLINCLUDE
Definition cmdmapper.h:60
@ CMD_SNIPWITHLINES
Definition cmdmapper.h:141
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
static const StringUnorderedSet g_plantumlEngine
Definition docnode.cpp:69
#define INTERNAL_ASSERT(x)
Definition docnode.cpp:51
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:48
const Mapper< CommandType > * cmdMapper
#define TRUE
Definition qcstring.h:37
T * get_last()
Returns a pointer to the last element in the list if that element exists and holds a T,...
Definition docnode.h:1410
DocNodeStack nodeStack
Definition docparser_p.h: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, TokenInfo::id, DocSimpleSect::Important, DocInclude::Include, DocInclude::IncWithLines, DocParserContext::inSeeBlock, INTERNAL_ASSERT, DocSimpleSect::Invar, Token::is_any_of(), isAliasCmd(), QCString::isEmpty(), DocParserContext::isExample, DocStyleChange::Italic, DocVerbatim::JavaDocCode, DocVerbatim::JavaDocLiteral, DocInclude::LatexInclude, DocVerbatim::LatexOnly, QCString::left(), DocTokenizer::lex(), DocIncOperator::Line, QCString::lower(), DocInclude::ManInclude, DocVerbatim::ManOnly, DocParserContext::memberDef, QCString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DocParamSect::Param, parse(), DocNode::parser(), DocVerbatim::PlantUML, GrowVector< T >::pop_back(), DocSimpleSect::Post, DocSimpleSect::Pre, DocSimpleSect::Remark, DocSimpleSect::Return, DocParamSect::RetVal, DocInclude::RtfInclude, DocVerbatim::RtfOnly, DocParserContext::scope, TokenInfo::sectionId, DocSimpleSect::See, DocVerbatim::setEngine(), DocTokenizer::setStateCode(), DocTokenizer::setStateDbOnly(), DocTokenizer::setStateDot(), DocTokenizer::setStateHtmlOnly(), DocTokenizer::setStateICode(), DocTokenizer::setStateILiteral(), DocTokenizer::setStateILiteralOpt(), DocTokenizer::setStateIVerbatim(), DocTokenizer::setStateLatexOnly(), DocTokenizer::setStateManOnly(), DocTokenizer::setStateMsc(), DocTokenizer::setStatePara(), DocTokenizer::setStatePlantUML(), DocTokenizer::setStatePlantUMLOpt(), DocTokenizer::setStateRtfOnly(), DocTokenizer::setStateSetScope(), DocTokenizer::setStateVerbatim(), DocTokenizer::setStateXmlOnly(), DocSimpleSect::Since, DocIncOperator::Skip, DocIncOperator::SkipLine, DocInclude::Snippet, DocInclude::SnippetWithLines, split(), QCString::str(), stripLeadingAndTrailingEmptyLines(), QCString::stripWhiteSpace(), HtmlEntityMapper::Sym_Amp, HtmlEntityMapper::Sym_At, HtmlEntityMapper::Sym_BSlash, HtmlEntityMapper::Sym_Dollar, HtmlEntityMapper::Sym_Dot, HtmlEntityMapper::Sym_DoubleColon, HtmlEntityMapper::Sym_Equal, HtmlEntityMapper::Sym_Exclam, HtmlEntityMapper::Sym_Greater, HtmlEntityMapper::Sym_Hash, HtmlEntityMapper::Sym_Less, HtmlEntityMapper::Sym_Minus, HtmlEntityMapper::Sym_Percent, HtmlEntityMapper::Sym_Pipe, HtmlEntityMapper::Sym_Plus, HtmlEntityMapper::Sym_Quest, HtmlEntityMapper::Sym_Quot, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TRUE, UNKNOWN, DocIncOperator::Until, DocSimpleSect::User, TokenInfo::verb, DocVerbatim::Verbatim, DocInclude::VerbInclude, DocSimpleSect::Version, QCString::view(), warn, warn_doc_error, DocSimpleSect::Warning, DocInclude::XmlInclude, and DocVerbatim::XmlOnly.

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3543 of file docnode.cpp.

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

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

3831{
3832 AUTO_TRACE("cmdName={}",cmdName);
3833 QCString saveCmdName = cmdName;
3834 Token tok=parser()->tokenizer.lex();
3835 if (!tok.is(TokenRetval::TK_WHITESPACE))
3836 {
3837 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3838 saveCmdName);
3839 return;
3840 }
3842 tok=parser()->tokenizer.lex();
3844 if (!tok.is(TokenRetval::TK_WORD))
3845 {
3846 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3847 tok.to_string(),saveCmdName);
3848 return;
3849 }
3850 QCString name = parser()->context.token->name;
3851 children().append<T>(parser(),thisVariant(),name,
3855 auto df = children().get_last<T>();
3856 if (!df->parse())
3857 {
3858 children().pop_back();
3859 }
3860}
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 5387 of file docnode.cpp.

5388{
5389 AUTO_TRACE("tagName={}",tagName);
5390 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5391 Token retval = Token::make_RetVal_OK();
5392 switch (tagId)
5393 {
5395 if (!insideUL(thisVariant()))
5396 {
5397 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5398 }
5399 else
5400 {
5401 retval = Token::make_RetVal_EndList();
5402 }
5403 break;
5405 if (!insideOL(thisVariant()))
5406 {
5407 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5408 }
5409 else
5410 {
5411 retval = Token::make_RetVal_EndList();
5412 }
5413 break;
5415 if (!insideLI(thisVariant()))
5416 {
5417 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5418 }
5419 else
5420 {
5421 // ignore </li> tags
5422 }
5423 break;
5425 if (!insideDetails(thisVariant()))
5426 {
5427 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5428 }
5429 else
5430 {
5431 retval = Token::make_RetVal_EndHtmlDetails();
5432 }
5433 break;
5436 {
5437 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5438 }
5439 else
5440 {
5441 retval = Token::make_RetVal_EndBlockQuote();
5442 }
5443 break;
5446 break;
5449 break;
5452 break;
5455 break;
5458 break;
5461 break;
5464 break;
5467 break;
5470 break;
5473 break;
5476 break;
5479 break;
5482 break;
5485 break;
5488 break;
5491 break;
5494 break;
5499 break;
5501 retval = Token::make_TK_NEWPARA();
5502 break;
5504 retval = Token::make_RetVal_EndDesc();
5505 break;
5507 // ignore </dt> tag
5508 break;
5510 // ignore </dd> tag
5511 break;
5513 retval = Token::make_RetVal_EndTable();
5514 break;
5516 retval = Token::make_RetVal_EndTableRow();
5517 break;
5519 retval = Token::make_RetVal_EndTableCell();
5520 break;
5522 retval = Token::make_RetVal_EndTableCell();
5523 break;
5527 // for time being ignore </t....> tag
5528 break;
5530 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5531 break;
5533 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5534 break;
5536 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5537 break;
5539 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5540 break;
5542 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5543 break;
5545 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5546 break;
5548 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5549 break;
5551 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5552 break;
5554 break;
5556 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5557 break;
5559 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5560 // ignore </a> tag (can be part of <a name=...></a>
5561 break;
5562
5564 break;
5566 retval = Token::make_TK_NEWPARA();
5567 break;
5580 retval = Token::make_RetVal_CloseXml();
5581 break;
5582 case HtmlTagType::XML_C:
5584 break;
5592 // These tags are defined in .Net but are currently unsupported
5593 break;
5595 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5596 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5597 break;
5598 default:
5599 // we should not get here!
5600 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5601 ASSERT(0);
5602 break;
5603 }
5604 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5605 return retval;
5606}
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 4073 of file docnode.cpp.

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

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

4915{
4916 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4917 Token retval = Token::make_RetVal_OK();
4918 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4919 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4922 {
4923 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4924 tagName);
4925 }
4926 switch (tagId)
4927 {
4929 if (!parser()->context.token->emptyTag)
4930 {
4931 children().append<DocHtmlList>(parser(),thisVariant(),
4932 tagHtmlAttribs,DocHtmlList::Unordered);
4933 retval=children().get_last<DocHtmlList>()->parse();
4934 }
4935 break;
4937 if (!parser()->context.token->emptyTag)
4938 {
4939 children().append<DocHtmlList>(parser(),thisVariant(),
4940 tagHtmlAttribs,DocHtmlList::Ordered);
4941 retval=children().get_last<DocHtmlList>()->parse();
4942 }
4943 break;
4945 if (parser()->context.token->emptyTag) break;
4947 {
4948 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
4949 }
4950 else
4951 {
4952 retval = Token::make_RetVal_ListItem();
4953 }
4954 break;
4956 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
4957 break;
4959 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
4960 break;
4962 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
4963 break;
4965 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
4966 break;
4968 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
4969 break;
4971 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
4972 break;
4974 if (parser()->context.token->emptyTag) break;
4975 if (parser()->context.xmlComment)
4976 // for C# source or inside a <summary> or <remark> section we
4977 // treat <code> as an XML tag (so similar to @code)
4978 {
4980 retval = handleStartCode();
4981 }
4982 else // normal HTML markup
4983 {
4984 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
4985 }
4986 break;
4988 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
4989 break;
4991 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
4992 break;
4994 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
4995 break;
4997 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
4998 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
4999 break;
5001 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5002 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5003 break;
5005 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5006 break;
5008 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5009 break;
5011 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5012 break;
5014 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5015 break;
5017 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5018 break;
5020 if (parser()->context.token->emptyTag) break;
5021 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5024 break;
5026 retval = Token::make_TK_NEWPARA();
5027 break;
5029 if (!parser()->context.token->emptyTag)
5030 {
5031 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5032 retval=children().get_last<DocHtmlDescList>()->parse();
5033 }
5034 break;
5036 if (insideDL(thisVariant()))
5037 {
5038 retval = Token::make_RetVal_DescTitle();
5039 }
5040 else
5041 {
5042 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5043 }
5044 break;
5046 if (insideDL(thisVariant()))
5047 {
5048 retval = Token::make_RetVal_DescData();
5049 }
5050 else
5051 {
5052 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5053 }
5054 break;
5056 if (!parser()->context.token->emptyTag)
5057 {
5058 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5059 retval=children().get_last<DocHtmlTable>()->parse();
5060 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5061 }
5062 break;
5064 retval = Token::make_RetVal_TableRow();
5065 break;
5067 retval = Token::make_RetVal_TableCell();
5068 break;
5070 retval = Token::make_RetVal_TableHCell();
5071 break;
5075 // for time being ignore </t....> tag
5076 break;
5078 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5079 break;
5081 {
5082 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5083 }
5084 break;
5086 {
5087 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5088 }
5089 break;
5091 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5092 break;
5094 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5095 break;
5097 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5098 break;
5100 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5101 break;
5103 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5104 break;
5106 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5107 break;
5109 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5110 break;
5112 {
5113 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5114 }
5115 break;
5117 if (!parser()->context.token->emptyTag)
5118 {
5119 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5120 retval=children().get_last<DocHtmlDetails>()->parse();
5121 }
5122 break;
5124 if (!parser()->context.token->emptyTag)
5125 {
5126 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5127 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5128 }
5129 break;
5130
5133 {
5134 if (!parser()->context.token->emptyTag)
5135 {
5137 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5138 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5139 if (d)
5140 {
5141 if (!d->summary()) // details section does not have a summary yet
5142 {
5143 d->parseSummary(n,parser()->context.token->attribs);
5144 }
5145 else
5146 {
5147 retval = Token::make_TK_NEWPARA();
5148 }
5149 }
5150 }
5151 }
5152 break;
5156 // fall through
5159 if (!children().empty())
5160 {
5161 retval = Token::make_TK_NEWPARA();
5162 }
5163 break;
5165 if (insideTable(thisVariant()))
5166 {
5167 retval = Token::make_RetVal_TableCell();
5168 }
5169 break;
5170 case HtmlTagType::XML_C:
5171 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5172 break;
5175 {
5177 QCString paramName;
5178 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5179 {
5180 if (paramName.isEmpty())
5181 {
5182 if (Config_getBool(WARN_NO_PARAMDOC))
5183 {
5184 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5185 }
5186 }
5187 else
5188 {
5189 retval = handleParamSection(paramName,
5191 TRUE);
5192 }
5193 }
5194 else
5195 {
5196 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5197 }
5198 }
5199 break;
5202 {
5203 QCString paramName;
5204 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5205 {
5206 //printf("paramName=%s\n",qPrint(paramName));
5207 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5208 children().append<DocWord>(parser(),thisVariant(),paramName);
5209 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5210 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5211 }
5212 else
5213 {
5214 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5215 }
5216 }
5217 break;
5219 {
5221 QCString exceptName;
5222 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5223 {
5224 unescapeCRef(exceptName);
5225 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5226 }
5227 else
5228 {
5229 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5230 }
5231 }
5232 break;
5235 if (insideTable(thisVariant()))
5236 {
5237 retval = Token::make_RetVal_TableRow();
5238 }
5239 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5240 {
5241 retval = Token::make_RetVal_ListItem();
5242 }
5243 else
5244 {
5245 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5246 }
5247 break;
5252 break;
5254 if (insideTable(thisVariant()))
5255 {
5256 retval = Token::make_RetVal_TableCell();
5257 }
5258 break;
5260 // I'm not sure if <see> is the same as <seealso> or if it
5261 // should you link a member without producing a section. The
5262 // C# specification is extremely vague about this (but what else
5263 // can we expect from Microsoft...)
5264 {
5265 QCString cref;
5266 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5267 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5268 {
5269 unescapeCRef(cref);
5270 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5271 {
5272 bool inSeeBlock = parser()->context.inSeeBlock;
5273 parser()->context.token->name = cref;
5276 parser()->context.inSeeBlock = inSeeBlock;
5277 }
5278 else // <see cref="...">...</see> style
5279 {
5280 //DocRef *ref = new DocRef(this,cref);
5281 //children().append(ref);
5282 //ref->parse();
5284 children().append<DocLink>(parser(),thisVariant(),cref);
5285 DocLink *lnk = children().get_last<DocLink>();
5286 QCString leftOver = lnk->parse(FALSE,TRUE);
5287 if (!leftOver.isEmpty())
5288 {
5289 children().append<DocWord>(parser(),thisVariant(),leftOver);
5290 }
5291 }
5292 }
5293 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5294 {
5295 bool inSeeBlock = parser()->context.inSeeBlock;
5296 parser()->context.token->name = cref;
5298 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5300 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5301 parser()->context.inSeeBlock = inSeeBlock;
5302 }
5303 else
5304 {
5305 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5306 }
5307 }
5308 break;
5310 {
5312 QCString cref;
5313 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5314 {
5315 unescapeCRef(cref);
5316 // Look for an existing "see" section
5317 DocNodeVariant *vss=nullptr;
5318 for (auto &n : children())
5319 {
5320 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5321 if (candidate && candidate->type()==DocSimpleSect::See)
5322 {
5323 vss = &n;
5324 }
5325 }
5326
5327 if (!vss) // start new section
5328 {
5329 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5330 vss = &children().back();
5331 }
5332
5333 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5334 retval = Token::make_RetVal_OK();
5335 }
5336 else
5337 {
5338 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5339 }
5340 }
5341 break;
5343 {
5344 QCString type;
5345 findAttribute(tagHtmlAttribs,"type",&type);
5347 HtmlAttribList emptyList;
5348 if (type=="number")
5349 {
5350 listType=DocHtmlList::Ordered;
5351 }
5352 if (type=="table")
5353 {
5354 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5355 retval=children().get_last<DocHtmlTable>()->parseXml();
5356 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5357 }
5358 else
5359 {
5360 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5361 retval=children().get_last<DocHtmlList>()->parseXml();
5362 }
5363 }
5364 break;
5367 // These tags are defined in .Net but are currently unsupported
5369 break;
5371 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5372 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5373 break;
5376 break;
5377 default:
5378 // we should not get here!
5379 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5380 ASSERT(0);
5381 break;
5382 }
5383 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5384 return retval;
5385}
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1479
const DocNodeVariant * summary() const
Definition docnode.h:864
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4073
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:4898
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 3746 of file docnode.cpp.

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

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

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

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

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

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

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

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

3911{
3912 AUTO_TRACE("cmdName={}",cmdName);
3913 QCString saveCmdName = cmdName;
3914 Token tok=parser()->tokenizer.lex();
3915 if (!tok.is(TokenRetval::TK_WHITESPACE))
3916 {
3917 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3918 cmdChar,qPrint(saveCmdName));
3919 return;
3920 }
3922 tok=parser()->tokenizer.lex(); // get the reference id
3923 if (!tok.is(TokenRetval::TK_WORD))
3924 {
3925 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3926 tok.to_string(),cmdChar,saveCmdName);
3927 goto endref;
3928 }
3929 children().append<DocRef>(parser(),thisVariant(),
3932 children().get_last<DocRef>()->parse();
3933endref:
3935}
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 4042 of file docnode.cpp.

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

3663{
3664 AUTO_TRACE();
3665 QCString fmt;
3666 QCString date;
3667 Token tok=parser()->tokenizer.lex();
3668 if (!tok.is(TokenRetval::TK_WHITESPACE))
3669 {
3670 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3671 cmdChar,cmdName);
3672 return;
3673 }
3675 tok = parser()->tokenizer.lex();
3676 if (!tok.is(TokenRetval::TK_WORD))
3677 {
3678 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3679 cmdChar,cmdName);
3681 return;
3682 }
3683 fmt = parser()->context.token->name;
3684
3686 tok = parser()->tokenizer.lex();
3687
3688 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3689 QCString specDate = specDateRaw.stripWhiteSpace();
3690 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3691 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3692 {
3693 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3694 cmdChar,cmdName);
3696 return;
3697 }
3698
3699 std::tm dat{};
3700 int specFormat=0;
3701 QCString err = dateTimeFromString(specDate,dat,specFormat);
3702 if (!err.isEmpty())
3703 {
3704 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3705 cmdChar,cmdName,err);
3707 return;
3708 }
3709
3710 int usedFormat=0;
3711 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3712
3713 // warn the user if the format contains markers that are not explicitly filled in
3714 for (int i=0;i<SF_NumBits;i++)
3715 {
3716 int bitMask = 1<<i;
3717 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3718 {
3719 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.",
3720 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3721 }
3722 }
3723
3724 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3725 if (specDateOnlyWS) // specDate is only whitespace
3726 {
3727 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3728 }
3730}
void setStateShowDate()
void setStateQuotedString()
QCString formatDateTime(const QCString &format, const std::tm &dt, int &formatUsed)
Return a string representation for a given std::tm value that is formatted according to the pattern g...
Definition datetime.cpp:175
QCString dateTimeFromString(const QCString &spec, std::tm &dt, int &format)
Returns the filled in std::tm for a given string representing a date and/or time.
Definition datetime.cpp:134
constexpr const char * SF_bit2str(int bitNumber)
Helper function that returns the name related one of the SF bits.
Definition datetime.h:32
constexpr int SF_NumBits
number of bits in SF vector
Definition datetime.h:27
#define err(fmt,...)
Definition message.h:127

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

Referenced by handleCommand().

◆ handleSimpleSection()

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

Definition at line 3354 of file docnode.cpp.

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

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

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

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

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

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

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

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

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

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

◆ setAttribs()

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

Definition at line 1115 of file docnode.h.

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

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1120 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1118 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1119 of file docnode.h.

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


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