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 handleSection (char cmdChar, const QCString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void handleShowDate (char cmdChar, const QCString &cmdName)
Token handleStartCode ()
Token handleHtmlHeader (const HtmlAttribList &tagHtmlAttribs, int level)
bool injectToken (Token tok, const QCString &tokText)
const HtmlAttribList & attribs () const
void setAttribs (const HtmlAttribList &attribs)
Public Member Functions inherited from DocCompoundNode
 DocCompoundNode (DocParser *parser, DocNodeVariant *parent)
DocNodeList & children ()
const DocNodeList & children () const
Public Member Functions inherited from DocNode
 DocNode (DocParser *parser, DocNodeVariant *parent)
 ~DocNode ()=default
DocNodeVariant * parent ()
const DocNodeVariant * parent () const
DocNodeVariant * thisVariant ()
const DocNodeVariant * thisVariant () const
void setThisVariant (DocNodeVariant *thisVariant)
DocParser * parser ()
const DocParser * parser () const
void setParent (DocNodeVariant *parent)
bool isPreformatted () const

Private Attributes

bool m_isFirst = false
bool m_isLast = false
HtmlAttribList m_attribs

Additional Inherited Members

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

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1088 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3481 of file docnode.cpp.

3481 :
3482 DocCompoundNode(parser,parent),
3483 m_isFirst(FALSE), m_isLast(FALSE)
3484{
3485}
DocCompoundNode::DocCompoundNode
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:141
DocNode::parser
DocParser * parser()
Definition docnode.h:98
DocNode::parent
DocNodeVariant * parent()
Definition docnode.h:90
DocPara::m_isFirst
bool m_isFirst
Definition docnode.h:1124
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1125
FALSE
#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 1120 of file docnode.h.

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

References m_attribs.

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

◆ handleCite()

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

Definition at line 3540 of file docnode.cpp.

3541{
3542 AUTO_TRACE();
3543 QCString saveCmdName = cmdName;
3544 // get the argument of the cite command.
3545 Token tok=parser()->tokenizer.lex();
3546
3547 CiteInfoOption option;
3548 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3549 {
3550 parser()->tokenizer.setStateOptions();
3551 parser()->tokenizer.lex();
3552 StringVector optList=split(parser()->context.token->name.str(),",");
3553 for (auto const &opt : optList)
3554 {
3555 if (opt == "number")
3556 {
3557 if (!option.isUnknown())
3558 {
3559 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3560 }
3561 else
3562 {
3563 option = CiteInfoOption::makeNumber();
3564 }
3565 }
3566 else if (opt == "year")
3567 {
3568 if (!option.isUnknown())
3569 {
3570 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3571 }
3572 else
3573 {
3574 option = CiteInfoOption::makeYear();
3575 }
3576 }
3577 else if (opt == "shortauthor")
3578 {
3579 if (!option.isUnknown())
3580 {
3581 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3582 }
3583 else
3584 {
3585 option = CiteInfoOption::makeShortAuthor();
3586 }
3587 }
3588 else if (opt == "nopar")
3589 {
3590 option.setNoPar();
3591 }
3592 else if (opt == "nocite")
3593 {
3594 option.setNoCite();
3595 }
3596 else
3597 {
3598 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unknown option specified with \\{}, discarding '{}'", saveCmdName, opt);
3599 }
3600 }
3601
3602 if (option.isUnknown()) option.changeToNumber();
3603
3604 parser()->tokenizer.setStatePara();
3605 tok=parser()->tokenizer.lex();
3606 if (!tok.is(TokenRetval::TK_WHITESPACE))
3607 {
3608 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3609 saveCmdName);
3610 return;
3611 }
3612 }
3613 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3614 {
3615 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3616 cmdChar,saveCmdName);
3617 return;
3618 }
3619 else
3620 {
3621 option = CiteInfoOption::makeNumber();
3622 }
3623
3624 parser()->tokenizer.setStateCite();
3625 tok=parser()->tokenizer.lex();
3626 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3627 {
3628 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"THE ONE unexpected end of comment block while parsing the "
3629 "argument of command '{:c}{}'",cmdChar,saveCmdName);
3630 return;
3631 }
3632 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3633 {
3634 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3635 tok.to_string(),cmdChar,saveCmdName);
3636 return;
3637 }
3638 parser()->context.token->sectionId = parser()->context.token->name;
3639 children().append<DocCite>(
3640 parser(),thisVariant(),parser()->context.token->name,parser()->context.context,option);
3641
3642 parser()->tokenizer.setStatePara();
3643}
CiteInfoOption::setNoCite
constexpr void setNoCite() noexcept
Definition cite.h:35
CiteInfoOption::makeNumber
static constexpr CiteInfoOption makeNumber()
Definition cite.h:29
CiteInfoOption::changeToNumber
constexpr void changeToNumber() noexcept
Definition cite.h:33
CiteInfoOption::setNoPar
constexpr void setNoPar() noexcept
Definition cite.h:34
CiteInfoOption::isUnknown
constexpr bool isUnknown() const noexcept
Definition cite.h:37
CiteInfoOption::makeYear
static constexpr CiteInfoOption makeYear()
Definition cite.h:31
CiteInfoOption::makeShortAuthor
static constexpr CiteInfoOption makeShortAuthor()
Definition cite.h:30
DocCompoundNode::children
DocNodeList & children()
Definition docnode.h:143
DocNode::thisVariant
DocNodeVariant * thisVariant()
Definition docnode.h:93
DocParser::tokenizer
DocTokenizer tokenizer
Definition docparser_p.h:148
DocParser::context
DocParserContext context
Definition docparser_p.h:147
DocTokenizer::setStateCite
void setStateCite()
Definition doctokenizer.l:2104
DocTokenizer::setStateOptions
void setStateOptions()
Definition doctokenizer.l:2176
DocTokenizer::setStatePara
void setStatePara()
Definition doctokenizer.l:1881
Token::is
bool is(TokenRetval rv) const
Definition doctokenizer.h:122
Token::to_string
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
Definition doctokenizer.h:93
Token::is_any_of
bool is_any_of(ARGS... args) const
Definition doctokenizer.h:117
StringVector
std::vector< std::string > StringVector
Definition containers.h:33
AUTO_TRACE
#define AUTO_TRACE(...)
Definition docnode.cpp:48
warn
#define warn(file, line, fmt,...)
Definition message.h:97
warn_doc_error
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
DocNodeList::append
void append(Args &&... args)
Append a new DocNodeVariant to the list by constructing it with type T and parameters Args.
Definition docnode.h:1405
DocParserContext::token
TokenInfo * token
Definition docparser_p.h:95
TokenInfo::sectionId
QCString sectionId
Definition doctokenizer.h:151
TokenInfo::name
QCString name
Definition doctokenizer.h:138
split
StringVector split(const std::string &s, const std::string &delimiter)
split input string s by string delimiter delimiter.
Definition util.cpp:6636

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

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

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_ENDMERMAID, CMD_ENDMSC, CMD_ENDPARBLOCK, CMD_ENDRTFONLY, CMD_ENDSECREFLIST, CMD_ENDUML, CMD_ENDVERBATIM, CMD_ENDXMLONLY, CMD_EQUAL, CMD_EXCEPTION, CMD_EXCLAMATION, CMD_FORMULA, CMD_GREATER, CMD_HASH, CMD_HTMLINCLUDE, CMD_HTMLONLY, CMD_IANCHOR, CMD_IFILE, CMD_ILINE, CMD_ILITERAL, CMD_IMAGE, CMD_IMPORTANT, CMD_INCLUDE, CMD_INCWITHLINES, CMD_INHERITDOC, CMD_INTERNAL, CMD_INTERNALREF, CMD_INVARIANT, CMD_IPREFIX, CMD_ISTARTCODE, CMD_IVERBATIM, CMD_JAVALINK, CMD_LATEXINCLUDE, CMD_LATEXONLY, CMD_LESS, CMD_LI, CMD_LINE, CMD_LINEBREAK, CMD_LINK, CMD_MANINCLUDE, CMD_MANONLY, CMD_MDASH, CMD_MERMAID, CMD_MERMAIDFILE, CMD_MINUS, CMD_MSC, CMD_MSCFILE, CMD_NDASH, CMD_NOTE, CMD_PAR, CMD_PARAGRAPH, CMD_PARAM, CMD_PARBLOCK, CMD_PERCENT, CMD_PIPE, CMD_PLANTUMLFILE, CMD_PLUS, CMD_POST, CMD_PRE, CMD_PUNT, CMD_QUESTION, CMD_QUOTE, CMD_REF, CMD_REMARK, CMD_RETURN, CMD_RETVAL, CMD_RTFINCLUDE, CMD_RTFONLY, CMD_SA, CMD_SECREFITEM, CMD_SECREFLIST, CMD_SECTION, CMD_SETSCOPE, CMD_SHOWDATE, CMD_SINCE, CMD_SKIP, CMD_SKIPLINE, CMD_SNIPPET, CMD_SNIPWITHLINES, CMD_STARTCODE, CMD_STARTUML, CMD_SUBPAGE, CMD_SUBPARAGRAPH, CMD_SUBSECTION, CMD_SUBSUBPARAGRAPH, CMD_SUBSUBSECTION, CMD_TPARAM, CMD_UNTIL, CMD_VERBATIM, CMD_VERBINCLUDE, CMD_VERSION, CMD_VHDLFLOW, CMD_WARNING, CMD_XMLINCLUDE, CMD_XMLONLY, CMD_XREFITEM, Mappers::cmdMapper, DocStyleChange::Code, Config_getBool, 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(), DocParser::handleIFile(), DocParser::handleILine(), DocParser::handleImage(), handleInclude(), handleIncludeOperator(), handleInheritDoc(), DocParser::handleInternalRef(), handleLink(), handleParamSection(), DocParser::handlePrefix(), DocParser::handleRef(), handleSection(), handleShowDate(), handleSimpleSection(), handleStartCode(), DocParser::handleStyleArgument(), handleVhdlFlow(), handleXRefItem(), DocParserContext::hasReturnCommand, DocInclude::HtmlInclude, DocVerbatim::HtmlOnly, TokenInfo::id, DocSimpleSect::Important, DocInclude::Include, DocInclude::IncWithLines, DocParserContext::inSeeBlock, INTERNAL_ASSERT, DocSimpleSect::Invar, Token::is_any_of(), isAliasCmd(), 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, DocVerbatim::Mermaid, QCString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DocParamSect::Param, DocParserContext::paramPosition, parse(), DocNode::parser(), DocVerbatim::PlantUML, GrowVector< T >::pop_back(), DocSimpleSect::Post, DocSimpleSect::Pre, DocSimpleSect::Remark, DocSimpleSect::Return, DocParamSect::RetVal, DocInclude::RtfInclude, DocVerbatim::RtfOnly, DocParserContext::scope, TokenInfo::sectionId, DocSimpleSect::See, DocVerbatim::setEngine(), DocTokenizer::setStateCode(), DocTokenizer::setStateDbOnly(), DocTokenizer::setStateDot(), DocTokenizer::setStateHtmlOnly(), DocTokenizer::setStateICode(), DocTokenizer::setStateILiteral(), DocTokenizer::setStateILiteralOpt(), DocTokenizer::setStateIVerbatim(), DocTokenizer::setStateLatexOnly(), DocTokenizer::setStateManOnly(), DocTokenizer::setStateMermaid(), DocTokenizer::setStateMermaidOpt(), DocTokenizer::setStateMsc(), DocTokenizer::setStatePara(), DocTokenizer::setStatePlantUML(), DocTokenizer::setStatePlantUMLOpt(), DocTokenizer::setStateRtfOnly(), DocTokenizer::setStateSetScope(), DocTokenizer::setStateVerbatim(), DocTokenizer::setStateXmlOnly(), DocSimpleSect::Since, DocIncOperator::Skip, DocIncOperator::SkipLine, DocInclude::Snippet, DocInclude::SnippetWithLines, split(), 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 3676 of file docnode.cpp.

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

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

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

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

3927{
3928 AUTO_TRACE("cmdName={}",cmdName);
3929 QCString saveCmdName = cmdName;
3930 Token tok=parser()->tokenizer.lex();
3931 if (!tok.is(TokenRetval::TK_WHITESPACE))
3932 {
3933 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3934 saveCmdName);
3935 return;
3936 }
3937 parser()->tokenizer.setStateFile();
3938 tok=parser()->tokenizer.lex();
3939 parser()->tokenizer.setStatePara();
3940 if (!tok.is(TokenRetval::TK_WORD))
3941 {
3942 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3943 tok.to_string(),saveCmdName);
3944 return;
3945 }
3946 QCString name = parser()->context.token->name;
3947 children().append<T>(parser(),thisVariant(),name,
3948 parser()->context.context,
3949 parser()->context.fileName,
3950 parser()->tokenizer.getLineNr());
3951 auto df = children().get_last<T>();
3952 if (!df->parse())
3953 {
3954 children().pop_back();
3955 }
3956}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2075
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2284
DocParserContext::fileName
QCString fileName
Definition docparser_p.h:71

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

Referenced by handleCommand().

◆ handleHtmlEndTag()

Token DocPara::handleHtmlEndTag ( const QCString & tagName)

Definition at line 5511 of file docnode.cpp.

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

4143{
4144 AUTO_TRACE();
4145 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4146 Token retval = children().get_last<DocHtmlHeader>()->parse();
4147 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4148}

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

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

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().

◆ handleInclude()

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

Definition at line 4006 of file docnode.cpp.

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

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

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

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

Referenced by handleCommand().

◆ handleInheritDoc()

void DocPara::handleInheritDoc ( )

Definition at line 4196 of file docnode.cpp.

4197{
4198 if (parser()->context.memberDef) // inheriting docs from a member
4199 {
4200 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4201 if (reMd) // member from which was inherited.
4202 {
4203 const MemberDef *thisMd = parser()->context.memberDef;
4204 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4205 parser()->pushContext();
4206 parser()->context.scope=reMd->getOuterScope();
4207 if (parser()->context.scope!=Doxygen::globalScope)
4208 {
4209 parser()->context.context=parser()->context.scope->name();
4210 }
4211 parser()->context.memberDef=reMd;
4212 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4213 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4214 parser()->context.copyStack.push_back(reMd);
4215 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4216 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4217 parser()->context.copyStack.pop_back();
4218 auto hasParamCommand = parser()->context.hasParamCommand;
4219 auto hasReturnCommand = parser()->context.hasReturnCommand;
4220 auto retvalsFound = parser()->context.retvalsFound;
4221 auto paramsFound = parser()->context.paramsFound;
4222 parser()->popContext();
4223 parser()->context.hasParamCommand = hasParamCommand;
4224 parser()->context.hasReturnCommand = hasReturnCommand;
4225 parser()->context.retvalsFound = retvalsFound;
4226 parser()->context.paramsFound = paramsFound;
4227 parser()->context.memberDef = thisMd;
4228 }
4229 }
4230}
Definition::briefDescription
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
Definition::documentation
virtual QCString documentation() const =0
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
Definition::name
virtual const QCString & name() const =0
DocParser::internalValidatingParseDoc
Token internalValidatingParseDoc(DocNodeVariant *parent, DocNodeList &children, const QCString &doc)
Definition docparser.cpp:1751
DocParser::popContext
void popContext()
Definition docparser.cpp:75
DocParser::pushContext
void pushContext()
Definition docparser.cpp:60
MemberDef::reimplements
virtual const MemberDef * reimplements() const =0
DocParserContext::retvalsFound
StringMultiSet retvalsFound
Definition docparser_p.h:76
DocParserContext::styleStack
DocStyleChangeStack styleStack
Definition docparser_p.h:68
DocParserContext::paramsFound
StringMultiSet paramsFound
Definition docparser_p.h:77
DocParserContext::copyStack
DefinitionStack copyStack
Definition docparser_p.h:70

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleLink()

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

Definition at line 3965 of file docnode.cpp.

3966{
3967 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3968 QCString saveCmdName = cmdName;
3969 Token tok=parser()->tokenizer.lex();
3970 if (!tok.is(TokenRetval::TK_WHITESPACE))
3971 {
3972 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3973 saveCmdName);
3974 return;
3975 }
3976 parser()->tokenizer.setStateLink();
3977 tok=parser()->tokenizer.lex();
3978 if (!tok.is(TokenRetval::TK_WORD))
3979 {
3980 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3981 tok.to_string(),saveCmdName);
3982 return;
3983 }
3984 if (saveCmdName == "javalink")
3985 {
3986 children().append<DocStyleChange>(parser(),thisVariant(),
3987 parser()->context.nodeStack.size(),
3988 DocStyleChange::Code,cmdName,TRUE);
3989 }
3990 parser()->tokenizer.setStatePara();
3991 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3992 DocLink *lnk = children().get_last<DocLink>();
3993 if (saveCmdName == "javalink")
3994 {
3995 children().append<DocStyleChange>(parser(),thisVariant(),
3996 parser()->context.nodeStack.size(),
3997 DocStyleChange::Code,cmdName,FALSE);
3998 }
3999 QCString leftOver = lnk->parse(isJavaLink);
4000 if (!leftOver.isEmpty())
4001 {
4002 children().append<DocWord>(parser(),thisVariant(),leftOver);
4003 }
4004}
DocTokenizer::setStateLink
void setStateLink()
Definition doctokenizer.l:2097

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

3521{
3522 AUTO_TRACE();
3523 DocParamSect *ps = nullptr;
3524 if (!children().empty() && // previous element
3525 (ps=children().get_last<DocParamSect>()) && // was a param sect
3526 ps->type()==t) // of same type
3527 { // append to previous section ps
3528 }
3529 else // start new section
3530 {
3531 children().append<DocParamSect>(parser(),thisVariant(),t);
3532 ps = children().get_last<DocParamSect>();
3533 }
3534 Token rv=ps->parse(cmdName,xmlContext,
3535 static_cast<DocParamSect::Direction>(direction));
3536 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3537 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3538}
DocParamSect::parse
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3438
DocParamSect::type
Type type() const
Definition docnode.h:1077

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().

◆ handleSection()

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

Definition at line 4111 of file docnode.cpp.

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

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

3797{
3798 AUTO_TRACE();
3799 QCString fmt;
3800 QCString date;
3801 Token tok=parser()->tokenizer.lex();
3802 if (!tok.is(TokenRetval::TK_WHITESPACE))
3803 {
3804 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3805 cmdChar,cmdName);
3806 return;
3807 }
3808 parser()->tokenizer.setStateQuotedString();
3809 tok = parser()->tokenizer.lex();
3810 if (!tok.is(TokenRetval::TK_WORD))
3811 {
3812 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3813 cmdChar,cmdName);
3814 parser()->tokenizer.setStatePara();
3815 return;
3816 }
3817 fmt = parser()->context.token->name;
3818
3819 parser()->tokenizer.setStateShowDate();
3820 tok = parser()->tokenizer.lex();
3821
3822 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3823 QCString specDate = specDateRaw.stripWhiteSpace();
3824 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3825 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3826 {
3827 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3828 cmdChar,cmdName);
3829 parser()->tokenizer.setStatePara();
3830 return;
3831 }
3832
3833 std::tm dat{};
3834 int specFormat=0;
3835 QCString err = dateTimeFromString(specDate,dat,specFormat);
3836 if (!err.isEmpty())
3837 {
3838 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3839 cmdChar,cmdName,err);
3840 parser()->tokenizer.setStatePara();
3841 return;
3842 }
3843
3844 int usedFormat=0;
3845 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3846
3847 // warn the user if the format contains markers that are not explicitly filled in
3848 for (int i=0;i<SF_NumBits;i++)
3849 {
3850 int bitMask = 1<<i;
3851 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3852 {
3853 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.",
3854 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3855 }
3856 }
3857
3858 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3859 if (specDateOnlyWS) // specDate is only whitespace
3860 {
3861 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3862 }
3863 parser()->tokenizer.setStatePara();
3864}
DocTokenizer::setStateShowDate
void setStateShowDate()
Definition doctokenizer.l:2214
DocTokenizer::setStateQuotedString
void setStateQuotedString()
Definition doctokenizer.l:2207
formatDateTime
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:174
dateTimeFromString
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:133
SF_bit2str
constexpr const char * SF_bit2str(int bitNumber)
Helper function that returns the name related one of the SF bits.
Definition datetime.h:32
SF_NumBits
constexpr int SF_NumBits
number of bits in SF vector
Definition datetime.h:27
err
#define err(fmt,...)
Definition message.h:127

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, dateTimeFromString(), 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 3487 of file docnode.cpp.

3488{
3489 AUTO_TRACE();
3490 DocSimpleSect *ss=nullptr;
3491 bool needsSeparator = FALSE;
3492 if (!children().empty() && // has previous element
3493 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3494 ss->type()==t && // of same type
3495 t!=DocSimpleSect::User) // but not user defined
3496 {
3497 // append to previous section
3498 needsSeparator = TRUE;
3499 }
3500 else // start new section
3501 {
3502 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3503 ss = children().get_last<DocSimpleSect>();
3504 }
3505 Token rv = Token::make_RetVal_OK();
3506 if (xmlContext)
3507 {
3508 return ss->parseXml();
3509 }
3510 else
3511 {
3512 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3513 }
3514 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3515}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3150
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:3204

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

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

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

3959{
3960 AUTO_TRACE();
3961 children().append<DocVhdlFlow>(parser(),thisVariant());
3962 children().get_last<DocVhdlFlow>()->parse();
3963}

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

3775{
3776 AUTO_TRACE();
3777 Token retval=parser()->tokenizer.lex();
3778 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3779 parser()->tokenizer.setStateXRefItem();
3780 retval=parser()->tokenizer.lex();
3781 if (retval.is(TokenRetval::RetVal_OK))
3782 {
3783 children().append<DocXRefItem>(parser(),thisVariant(),
3784 parser()->context.token->id,parser()->context.token->name);
3785 DocXRefItem *ref = children().get_last<DocXRefItem>();
3786 if (!ref->parse())
3787 {
3788 children().pop_back();
3789 }
3790 }
3791 parser()->tokenizer.setStatePara();
3792 return retval;
3793}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2068

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

4154{
4155 AUTO_TRACE();
4156 parser()->context.token->name = tokText;
4157 return parser()->defaultHandleToken(thisVariant(),tok,children());
4158}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token &tok, DocNodeList &children, bool handleWord=TRUE)
Definition docparser.cpp:1351

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 1093 of file docnode.h.

1093{ return children().empty(); }
GrowVector::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 1096 of file docnode.h.

1096{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1097 of file docnode.h.

1097{ return m_isLast; }

References m_isLast.

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

◆ markFirst()

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

Definition at line 1094 of file docnode.h.

1094{ m_isFirst=v; }

References m_isFirst, and TRUE.

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

◆ markLast()

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

Definition at line 1095 of file docnode.h.

1095{ m_isLast=v; }

References m_isLast, and TRUE.

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

◆ parse()

Token DocPara::parse ( )

Definition at line 5784 of file docnode.cpp.

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

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(), 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 1121 of file docnode.h.

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

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1126 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1124 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1125 of file docnode.h.

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

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