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

Node representing a paragraph in the documentation tree. More...

#include <src/docnode.h>

Inheritance diagram for DocPara:
Collaboration diagram for DocPara:

Public Member Functions

 DocPara (DocParser *parser, DocNodeVariant *parent)
Token parse ()
bool isEmpty () const
void markFirst (bool v=TRUE)
void markLast (bool v=TRUE)
bool isFirst () const
bool isLast () const
Token handleCommand (char cmdChar, const QCString &cmdName)
Token handleHtmlStartTag (const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Token handleHtmlEndTag (const QCString &tagName)
Token handleSimpleSection (DocSimpleSect::Type t, bool xmlContext=FALSE)
Token handleXRefItem ()
Token handleParamSection (const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
void handleIncludeOperator (const QCString &cmdName, DocIncOperator::Type t)
template<class T>
void handleFile (const QCString &cmdName)
void handleInclude (const QCString &cmdName, DocInclude::Type t)
void handleLink (const QCString &cmdName, bool isJavaLink)
void handleCite (char cmdChar, const QCString &cmdName)
void handleDoxyConfig (char cmdChar, const QCString &cmdName)
void handleEmoji (char cmdChar, const QCString &cmdName)
void handleRef (char cmdChar, const QCString &cmdName)
void handleSection (char cmdChar, const QCString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void 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 1079 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3432 of file docnode.cpp.

3432 :
3433 DocCompoundNode(parser,parent),
3434 m_isFirst(FALSE), m_isLast(FALSE)
3435{
3436}
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:1116
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1117
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 1112 of file docnode.h.

1112{ return m_attribs; }
DocPara::m_attribs
HtmlAttribList m_attribs
Definition docnode.h:1118

References m_attribs.

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

◆ handleCite()

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

Definition at line 3491 of file docnode.cpp.

3492{
3493 AUTO_TRACE();
3494 QCString saveCmdName = cmdName;
3495 // get the argument of the cite command.
3496 Token tok=parser()->tokenizer.lex();
3497
3498 CiteInfoOption option;
3499 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3500 {
3501 parser()->tokenizer.setStateOptions();
3502 parser()->tokenizer.lex();
3503 StringVector optList=split(parser()->context.token->name.str(),",");
3504 for (auto const &opt : optList)
3505 {
3506 if (opt == "number")
3507 {
3508 if (!option.isUnknown())
3509 {
3510 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3511 }
3512 else
3513 {
3514 option = CiteInfoOption::makeNumber();
3515 }
3516 }
3517 else if (opt == "year")
3518 {
3519 if (!option.isUnknown())
3520 {
3521 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3522 }
3523 else
3524 {
3525 option = CiteInfoOption::makeYear();
3526 }
3527 }
3528 else if (opt == "shortauthor")
3529 {
3530 if (!option.isUnknown())
3531 {
3532 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple options specified with \\{}, discarding '{}'", saveCmdName, opt);
3533 }
3534 else
3535 {
3536 option = CiteInfoOption::makeShortAuthor();
3537 }
3538 }
3539 else if (opt == "nopar")
3540 {
3541 option.setNoPar();
3542 }
3543 else if (opt == "nocite")
3544 {
3545 option.setNoCite();
3546 }
3547 else
3548 {
3549 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unknown option specified with \\{}, discarding '{}'", saveCmdName, opt);
3550 }
3551 }
3552
3553 if (option.isUnknown()) option.changeToNumber();
3554
3555 parser()->tokenizer.setStatePara();
3556 tok=parser()->tokenizer.lex();
3557 if (!tok.is(TokenRetval::TK_WHITESPACE))
3558 {
3559 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3560 saveCmdName);
3561 return;
3562 }
3563 }
3564 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3565 {
3566 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3567 cmdChar,saveCmdName);
3568 return;
3569 }
3570 else
3571 {
3572 option = CiteInfoOption::makeNumber();
3573 }
3574
3575 parser()->tokenizer.setStateCite();
3576 tok=parser()->tokenizer.lex();
3577 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3578 {
3579 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"THE ONE unexpected end of comment block while parsing the "
3580 "argument of command '{:c}{}'",cmdChar,saveCmdName);
3581 return;
3582 }
3583 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3584 {
3585 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3586 tok.to_string(),cmdChar,saveCmdName);
3587 return;
3588 }
3589 parser()->context.token->sectionId = parser()->context.token->name;
3590 children().append<DocCite>(
3591 parser(),thisVariant(),parser()->context.token->name,parser()->context.context,option);
3592
3593 parser()->tokenizer.setStatePara();
3594}
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:145
DocParser::context
DocParserContext context
Definition docparser_p.h:144
DocTokenizer::setStateCite
void setStateCite()
Definition doctokenizer.l:2049
DocTokenizer::setStateOptions
void setStateOptions()
Definition doctokenizer.l:2121
DocTokenizer::setStatePara
void setStatePara()
Definition doctokenizer.l:1843
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:47
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:1397
DocParserContext::token
TokenInfo * token
Definition docparser_p.h:93
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:6618

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

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

References DocNodeList::append(), DocSimpleSect::Attention, DocSimpleSect::Author, DocSimpleSect::Authors, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocCompoundNode::children(), CMD_ADDINDEX, CMD_AMP, CMD_ANCHOR, CMD_AT, CMD_ATTENTION, CMD_AUTHOR, CMD_AUTHORS, CMD_BOLD, CMD_BSLASH, CMD_CITE, CMD_CODE, CMD_COPYBRIEF, CMD_COPYDETAILS, CMD_COPYDOC, CMD_COPYRIGHT, CMD_DATE, CMD_DBONLY, CMD_DCOLON, CMD_DIAFILE, CMD_DOCBOOKINCLUDE, CMD_DOLLAR, CMD_DONTINCLUDE, CMD_DOT, CMD_DOTFILE, CMD_DOXYCONFIG, CMD_EMOJI, CMD_EMPHASIS, CMD_ENDCODE, CMD_ENDDBONLY, CMD_ENDDOT, CMD_ENDHTMLONLY, CMD_ENDICODE, CMD_ENDILITERAL, CMD_ENDINTERNAL, CMD_ENDIVERBATIM, CMD_ENDLATEXONLY, CMD_ENDLINK, CMD_ENDMANONLY, CMD_ENDMSC, CMD_ENDPARBLOCK, CMD_ENDRTFONLY, CMD_ENDSECREFLIST, CMD_ENDUML, CMD_ENDVERBATIM, CMD_ENDXMLONLY, CMD_EQUAL, CMD_EXCEPTION, CMD_EXCLAMATION, CMD_FORMULA, CMD_GREATER, CMD_HASH, CMD_HTMLINCLUDE, CMD_HTMLONLY, CMD_IANCHOR, CMD_IFILE, CMD_ILINE, CMD_ILITERAL, CMD_IMAGE, CMD_IMPORTANT, CMD_INCLUDE, CMD_INCWITHLINES, CMD_INHERITDOC, CMD_INTERNAL, CMD_INTERNALREF, CMD_INVARIANT, CMD_IPREFIX, CMD_ISTARTCODE, CMD_IVERBATIM, CMD_JAVALINK, CMD_LATEXINCLUDE, CMD_LATEXONLY, CMD_LESS, CMD_LI, CMD_LINE, CMD_LINEBREAK, CMD_LINK, CMD_MANINCLUDE, CMD_MANONLY, CMD_MDASH, CMD_MINUS, CMD_MSC, CMD_MSCFILE, CMD_NDASH, CMD_NOTE, CMD_PAR, CMD_PARAGRAPH, CMD_PARAM, CMD_PARBLOCK, CMD_PERCENT, CMD_PIPE, CMD_PLANTUMLFILE, CMD_PLUS, CMD_POST, CMD_PRE, CMD_PUNT, CMD_QUESTION, CMD_QUOTE, CMD_REF, CMD_REMARK, CMD_RETURN, CMD_RETVAL, CMD_RTFINCLUDE, CMD_RTFONLY, CMD_SA, CMD_SECREFITEM, CMD_SECREFLIST, CMD_SECTION, CMD_SETSCOPE, CMD_SHOWDATE, CMD_SINCE, CMD_SKIP, CMD_SKIPLINE, CMD_SNIPPET, CMD_SNIPWITHLINES, CMD_STARTCODE, CMD_STARTUML, CMD_SUBPAGE, CMD_SUBPARAGRAPH, CMD_SUBSECTION, CMD_SUBSUBPARAGRAPH, CMD_SUBSUBSECTION, CMD_TPARAM, CMD_UNTIL, CMD_VERBATIM, CMD_VERBINCLUDE, CMD_VERSION, CMD_VHDLFLOW, CMD_WARNING, CMD_XMLINCLUDE, CMD_XMLONLY, CMD_XREFITEM, Mappers::cmdMapper, DocStyleChange::Code, Config_getBool, Config_getString, DocParser::context, DocParserContext::context, DocSimpleSect::Copyright, DocSimpleSect::Date, DocParser::defaultHandleTitleAndSize(), DocInclude::DocbookInclude, DocVerbatim::DocbookOnly, DocInclude::DontInclude, DocVerbatim::Dot, DocParserContext::exampleName, DocParamSect::Exception, FALSE, QCString::find(), g_plantumlEngine, DocNodeList::get_last(), Doxygen::globalScope, DocParser::handleAnchor(), handleCite(), handleDoxyConfig(), handleEmoji(), handleFile(), DocParser::handleIFile(), DocParser::handleILine(), DocParser::handleImage(), handleInclude(), handleIncludeOperator(), handleInheritDoc(), DocParser::handleInternalRef(), handleLink(), handleParamSection(), DocParser::handlePrefix(), handleRef(), handleSection(), handleShowDate(), handleSimpleSection(), handleStartCode(), DocParser::handleStyleArgument(), handleVhdlFlow(), handleXRefItem(), DocParserContext::hasReturnCommand, DocInclude::HtmlInclude, DocVerbatim::HtmlOnly, TokenInfo::id, DocSimpleSect::Important, DocInclude::Include, DocInclude::IncWithLines, DocParserContext::inSeeBlock, INTERNAL_ASSERT, DocSimpleSect::Invar, Token::is_any_of(), isAliasCmd(), QCString::isEmpty(), DocParserContext::isExample, DocStyleChange::Italic, DocVerbatim::JavaDocCode, DocVerbatim::JavaDocLiteral, DocInclude::LatexInclude, DocVerbatim::LatexOnly, QCString::left(), DocTokenizer::lex(), DocIncOperator::Line, QCString::lower(), DocInclude::ManInclude, DocVerbatim::ManOnly, DocParserContext::memberDef, QCString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DocParamSect::Param, parse(), DocNode::parser(), DocVerbatim::PlantUML, GrowVector< T >::pop_back(), DocSimpleSect::Post, DocSimpleSect::Pre, DocSimpleSect::Remark, DocSimpleSect::Return, DocParamSect::RetVal, DocInclude::RtfInclude, DocVerbatim::RtfOnly, DocParserContext::scope, TokenInfo::sectionId, DocSimpleSect::See, DocVerbatim::setEngine(), DocTokenizer::setStateCode(), DocTokenizer::setStateDbOnly(), DocTokenizer::setStateDot(), DocTokenizer::setStateHtmlOnly(), DocTokenizer::setStateICode(), DocTokenizer::setStateILiteral(), DocTokenizer::setStateILiteralOpt(), DocTokenizer::setStateIVerbatim(), DocTokenizer::setStateLatexOnly(), DocTokenizer::setStateManOnly(), DocTokenizer::setStateMsc(), DocTokenizer::setStatePara(), DocTokenizer::setStatePlantUML(), DocTokenizer::setStatePlantUMLOpt(), DocTokenizer::setStateRtfOnly(), DocTokenizer::setStateSetScope(), DocTokenizer::setStateVerbatim(), DocTokenizer::setStateXmlOnly(), DocSimpleSect::Since, DocIncOperator::Skip, DocIncOperator::SkipLine, DocInclude::Snippet, DocInclude::SnippetWithLines, split(), QCString::str(), stripLeadingAndTrailingEmptyLines(), QCString::stripWhiteSpace(), HtmlEntityMapper::Sym_Amp, HtmlEntityMapper::Sym_At, HtmlEntityMapper::Sym_BSlash, HtmlEntityMapper::Sym_Dollar, HtmlEntityMapper::Sym_Dot, HtmlEntityMapper::Sym_DoubleColon, HtmlEntityMapper::Sym_Equal, HtmlEntityMapper::Sym_Exclam, HtmlEntityMapper::Sym_Greater, HtmlEntityMapper::Sym_Hash, HtmlEntityMapper::Sym_Less, HtmlEntityMapper::Sym_Minus, HtmlEntityMapper::Sym_Percent, HtmlEntityMapper::Sym_Pipe, HtmlEntityMapper::Sym_Plus, HtmlEntityMapper::Sym_Quest, HtmlEntityMapper::Sym_Quot, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TRUE, UNKNOWN, DocIncOperator::Until, DocSimpleSect::User, TokenInfo::verb, DocVerbatim::Verbatim, DocInclude::VerbInclude, DocSimpleSect::Version, QCString::view(), warn, warn_doc_error, DocSimpleSect::Warning, DocInclude::XmlInclude, and DocVerbatim::XmlOnly.

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3627 of file docnode.cpp.

3628{
3629 // get the argument of the cite command.
3630 Token tok=parser()->tokenizer.lex();
3631 if (!tok.is(TokenRetval::TK_WHITESPACE))
3632 {
3633 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3634 cmdChar,cmdName);
3635 return;
3636 }
3637 parser()->tokenizer.setStateDoxyConfig();
3638 tok=parser()->tokenizer.lex();
3639 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3640 {
3641 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3642 "argument of command '{:c}{}'",cmdChar,cmdName);
3643 return;
3644 }
3645 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3646 {
3647 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3648 tok.to_string(),cmdChar,cmdName);
3649 return;
3650 }
3651 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3652 if (opt)
3653 {
3654 QCString optionValue;
3655 switch (opt->kind())
3656 {
3657 case ConfigOption::O_Bool:
3658 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3659 break;
3660 case ConfigOption::O_String:
3661 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3662 break;
3663 case ConfigOption::O_Enum:
3664 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3665 break;
3666 case ConfigOption::O_Int:
3667 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3668 break;
3669 case ConfigOption::O_List:
3670 {
3671 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3672 optionValue="";
3673 if (!lst->empty())
3674 {
3675 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3676 static const reg::Ex marker(R"(@(\d+))");
3677 reg::Iterator it(lstFormat,marker);
3678 reg::Iterator end;
3679 size_t index=0;
3680 // now replace all markers with the real text
3681 for ( ; it!=end ; ++it)
3682 {
3683 const auto &match = *it;
3684 size_t newIndex = match.position();
3685 size_t matchLen = match.length();
3686 optionValue += lstFormat.substr(index,newIndex-index);
3687 unsigned long entryIndex = std::stoul(match[1].str());
3688 if (entryIndex<(unsigned long)lst->size())
3689 {
3690 optionValue += lst->at(entryIndex);
3691 }
3692 index=newIndex+matchLen;
3693 }
3694 optionValue+=lstFormat.substr(index);
3695 }
3696 }
3697 break;
3698 case ConfigOption::O_Obsolete:
3699 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3700 cmdChar,cmdName,parser()->context.token->name);
3701 break;
3702 case ConfigOption::O_Disabled:
3703 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3704 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3705 cmdChar,cmdName,parser()->context.token->name);
3706 break;
3707 case ConfigOption::O_Info:
3708 // nothing to show here
3709 break;
3710 }
3711 if (!optionValue.isEmpty())
3712 {
3713 children().append<DocWord>(parser(),thisVariant(),optionValue);
3714 }
3715 }
3716 else
3717 {
3718 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3719 cmdChar,cmdName,parser()->context.token->name);
3720 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3721 }
3722 parser()->tokenizer.setStatePara();
3723}
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:2056
QCString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:593
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 3596 of file docnode.cpp.

3597{
3598 AUTO_TRACE();
3599 // get the argument of the emoji command.
3600 Token tok=parser()->tokenizer.lex();
3601 if (!tok.is(TokenRetval::TK_WHITESPACE))
3602 {
3603 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3604 cmdChar,cmdName);
3605 return;
3606 }
3607 parser()->tokenizer.setStateEmoji();
3608 tok=parser()->tokenizer.lex();
3609 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3610 {
3611 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3612 "argument of command '{:c}{}'",cmdChar,cmdName);
3613 parser()->tokenizer.setStatePara();
3614 return;
3615 }
3616 else if (!tok.is(TokenRetval::TK_WORD))
3617 {
3618 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3619 tok.to_string(),cmdChar,cmdName);
3620 parser()->tokenizer.setStatePara();
3621 return;
3622 }
3623 children().append<DocEmoji>(parser(),thisVariant(),parser()->context.token->name);
3624 parser()->tokenizer.setStatePara();
3625}
DocTokenizer::setStateEmoji
void setStateEmoji()
Definition doctokenizer.l:2137

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

Referenced by handleCommand().

◆ handleFile()

template<class T>
void DocPara::handleFile ( const QCString & cmdName)

Definition at line 3877 of file docnode.cpp.

3878{
3879 AUTO_TRACE("cmdName={}",cmdName);
3880 QCString saveCmdName = cmdName;
3881 Token tok=parser()->tokenizer.lex();
3882 if (!tok.is(TokenRetval::TK_WHITESPACE))
3883 {
3884 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3885 saveCmdName);
3886 return;
3887 }
3888 parser()->tokenizer.setStateFile();
3889 tok=parser()->tokenizer.lex();
3890 parser()->tokenizer.setStatePara();
3891 if (!tok.is(TokenRetval::TK_WORD))
3892 {
3893 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3894 tok.to_string(),saveCmdName);
3895 return;
3896 }
3897 QCString name = parser()->context.token->name;
3898 children().append<T>(parser(),thisVariant(),name,
3899 parser()->context.context,
3900 parser()->context.fileName,
3901 parser()->tokenizer.getLineNr());
3902 auto df = children().get_last<T>();
3903 if (!df->parse())
3904 {
3905 children().pop_back();
3906 }
3907}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2020
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2229
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 5441 of file docnode.cpp.

5442{
5443 AUTO_TRACE("tagName={}",tagName);
5444 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5445 Token retval = Token::make_RetVal_OK();
5446 switch (tagId)
5447 {
5448 case HtmlTagType::HTML_UL:
5449 if (!insideUL(thisVariant()))
5450 {
5451 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5452 }
5453 else
5454 {
5455 retval = Token::make_RetVal_EndList();
5456 }
5457 break;
5458 case HtmlTagType::HTML_OL:
5459 if (!insideOL(thisVariant()))
5460 {
5461 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5462 }
5463 else
5464 {
5465 retval = Token::make_RetVal_EndList();
5466 }
5467 break;
5468 case HtmlTagType::HTML_LI:
5469 if (!insideLI(thisVariant()))
5470 {
5471 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5472 }
5473 else
5474 {
5475 // ignore </li> tags
5476 }
5477 break;
5478 case HtmlTagType::HTML_DETAILS:
5479 if (!insideDetails(thisVariant()))
5480 {
5481 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5482 }
5483 else
5484 {
5485 retval = Token::make_RetVal_EndHtmlDetails();
5486 }
5487 break;
5488 case HtmlTagType::HTML_BLOCKQUOTE:
5489 if (!insideBlockQuote(thisVariant()))
5490 {
5491 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5492 }
5493 else
5494 {
5495 retval = Token::make_RetVal_EndBlockQuote();
5496 }
5497 break;
5498 case HtmlTagType::HTML_BOLD:
5499 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Bold,tagName);
5500 break;
5501 case HtmlTagType::HTML_S:
5502 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::S,"s");
5503 break;
5504 case HtmlTagType::HTML_STRIKE:
5505 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Strike,tagName);
5506 break;
5507 case HtmlTagType::HTML_DEL:
5508 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Del,tagName);
5509 break;
5510 case HtmlTagType::HTML_UNDERLINE:
5511 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Underline,tagName);
5512 break;
5513 case HtmlTagType::HTML_INS:
5514 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Ins,tagName);
5515 break;
5516 case HtmlTagType::HTML_CODE:
5517 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5518 break;
5519 case HtmlTagType::HTML_KBD:
5520 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Kbd,tagName);
5521 break;
5522 case HtmlTagType::HTML_TT:
5523 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Typewriter,tagName);
5524 break;
5525 case HtmlTagType::HTML_EMPHASIS:
5526 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Italic,tagName);
5527 break;
5528 case HtmlTagType::HTML_DIV:
5529 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5530 break;
5531 case HtmlTagType::HTML_SPAN:
5532 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5533 break;
5534 case HtmlTagType::HTML_SUB:
5535 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Subscript,tagName);
5536 break;
5537 case HtmlTagType::HTML_SUP:
5538 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Superscript,tagName);
5539 break;
5540 case HtmlTagType::HTML_CENTER:
5541 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Center,tagName);
5542 break;
5543 case HtmlTagType::HTML_SMALL:
5544 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Small,tagName);
5545 break;
5546 case HtmlTagType::HTML_CITE:
5547 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Cite,tagName);
5548 break;
5549 case HtmlTagType::HTML_PRE:
5550 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Preformatted,tagName);
5551 setInsidePreformatted(FALSE);
5552 parser()->tokenizer.setInsidePre(FALSE);
5553 break;
5554 case HtmlTagType::HTML_P:
5555 retval = Token::make_TK_NEWPARA();
5556 break;
5557 case HtmlTagType::HTML_DL:
5558 retval = Token::make_RetVal_EndDesc();
5559 break;
5560 case HtmlTagType::HTML_DT:
5561 // ignore </dt> tag
5562 break;
5563 case HtmlTagType::HTML_DD:
5564 // ignore </dd> tag
5565 break;
5566 case HtmlTagType::HTML_TABLE:
5567 retval = Token::make_RetVal_EndTable();
5568 break;
5569 case HtmlTagType::HTML_TR:
5570 retval = Token::make_RetVal_EndTableRow();
5571 break;
5572 case HtmlTagType::HTML_TD:
5573 retval = Token::make_RetVal_EndTableCell();
5574 break;
5575 case HtmlTagType::HTML_TH:
5576 retval = Token::make_RetVal_EndTableCell();
5577 break;
5578 case HtmlTagType::HTML_THEAD:
5579 case HtmlTagType::HTML_TBODY:
5580 case HtmlTagType::HTML_TFOOT:
5581 // for time being ignore </t....> tag
5582 break;
5583 case HtmlTagType::HTML_CAPTION:
5584 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5585 break;
5586 case HtmlTagType::HTML_BR:
5587 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5588 break;
5589 case HtmlTagType::HTML_H1:
5590 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5591 break;
5592 case HtmlTagType::HTML_H2:
5593 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5594 break;
5595 case HtmlTagType::HTML_H3:
5596 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5597 break;
5598 case HtmlTagType::HTML_H4:
5599 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5600 break;
5601 case HtmlTagType::HTML_H5:
5602 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5603 break;
5604 case HtmlTagType::HTML_H6:
5605 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5606 break;
5607 case HtmlTagType::HTML_IMG:
5608 break;
5609 case HtmlTagType::HTML_HR:
5610 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5611 break;
5612 case HtmlTagType::HTML_A:
5613 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5614 // ignore </a> tag (can be part of <a name=...></a>
5615 break;
5616
5617 case HtmlTagType::XML_TERM:
5618 break;
5619 case HtmlTagType::XML_SUMMARY:
5620 retval = Token::make_TK_NEWPARA();
5621 break;
5622 case HtmlTagType::XML_REMARKS:
5623 case HtmlTagType::XML_PARA:
5624 case HtmlTagType::XML_VALUE:
5625 case HtmlTagType::XML_EXAMPLE:
5626 case HtmlTagType::XML_PARAM:
5627 case HtmlTagType::XML_LIST:
5628 case HtmlTagType::XML_TYPEPARAM:
5629 case HtmlTagType::XML_RETURNS:
5630 case HtmlTagType::XML_SEE:
5631 case HtmlTagType::XML_SEEALSO:
5632 case HtmlTagType::XML_EXCEPTION:
5633 case HtmlTagType::XML_INHERITDOC:
5634 retval = Token::make_RetVal_CloseXml();
5635 break;
5636 case HtmlTagType::XML_C:
5637 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5638 break;
5639 case HtmlTagType::XML_ITEM:
5640 case HtmlTagType::XML_LISTHEADER:
5641 case HtmlTagType::XML_INCLUDE:
5642 case HtmlTagType::XML_PERMISSION:
5643 case HtmlTagType::XML_DESCRIPTION:
5644 case HtmlTagType::XML_PARAMREF:
5645 case HtmlTagType::XML_TYPEPARAMREF:
5646 // These tags are defined in .Net but are currently unsupported
5647 break;
5648 case HtmlTagType::UNKNOWN:
5649 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5650 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5651 break;
5652 default:
5653 // we should not get here!
5654 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5655 ASSERT(0);
5656 break;
5657 }
5658 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5659 return retval;
5660}
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:637
DocTokenizer::setInsidePre
void setInsidePre(bool b)
Definition doctokenizer.l:2173
HtmlTagType
HtmlTagType
Definition cmdmapper.h:170
insideUL
bool insideUL(const DocNodeVariant *n)
Definition docparser_p.h:217
insideLI
bool insideLI(const DocNodeVariant *n)
Definition docparser_p.h:192
insideBlockQuote
bool insideBlockQuote(const DocNodeVariant *n)
Definition docparser_p.h:203
insideDetails
bool insideDetails(const DocNodeVariant *n)
Definition docparser_p.h:262
insideOL
bool insideOL(const DocNodeVariant *n)
Definition docparser_p.h:234
Mappers::htmlTagMapper
const Mapper< HtmlTagType > * htmlTagMapper
Definition cmdmapper.cpp:252
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 4129 of file docnode.cpp.

4130{
4131 AUTO_TRACE();
4132 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4133 Token retval = children().get_last<DocHtmlHeader>()->parse();
4134 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4135}

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

4972{
4973 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4974 Token retval = Token::make_RetVal_OK();
4975 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4976 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4977 tagId!=HtmlTagType::UNKNOWN && tagId!=HtmlTagType::HTML_IMG && tagId!=HtmlTagType::HTML_BR && tagId!=HtmlTagType::HTML_HR && tagId!=HtmlTagType::HTML_P
4978 && tagId!=HtmlTagType::HTML_DIV && tagId!=HtmlTagType::HTML_SPAN)
4979 {
4980 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4981 tagName);
4982 }
4983 switch (tagId)
4984 {
4985 case HtmlTagType::HTML_UL:
4986 if (!parser()->context.token->emptyTag)
4987 {
4988 children().append<DocHtmlList>(parser(),thisVariant(),
4989 tagHtmlAttribs,DocHtmlList::Unordered);
4990 retval=children().get_last<DocHtmlList>()->parse();
4991 }
4992 break;
4993 case HtmlTagType::HTML_OL:
4994 if (!parser()->context.token->emptyTag)
4995 {
4996 children().append<DocHtmlList>(parser(),thisVariant(),
4997 tagHtmlAttribs,DocHtmlList::Ordered);
4998 retval=children().get_last<DocHtmlList>()->parse();
4999 }
5000 break;
5001 case HtmlTagType::HTML_LI:
5002 if (parser()->context.token->emptyTag) break;
5003 if (!insideUL(thisVariant()) && !insideOL(thisVariant()))
5004 {
5005 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
5006 }
5007 else
5008 {
5009 retval = Token::make_RetVal_ListItem();
5010 }
5011 break;
5012 case HtmlTagType::HTML_BOLD:
5013 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
5014 break;
5015 case HtmlTagType::HTML_S:
5016 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
5017 break;
5018 case HtmlTagType::HTML_STRIKE:
5019 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
5020 break;
5021 case HtmlTagType::HTML_DEL:
5022 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
5023 break;
5024 case HtmlTagType::HTML_UNDERLINE:
5025 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
5026 break;
5027 case HtmlTagType::HTML_INS:
5028 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
5029 break;
5030 case HtmlTagType::HTML_CODE:
5031 if (parser()->context.token->emptyTag) break;
5032 if (parser()->context.xmlComment)
5033 // for C# source or inside a <summary> or <remark> section we
5034 // treat <code> as an XML tag (so similar to @code)
5035 {
5036 parser()->tokenizer.setStateXmlCode();
5037 retval = handleStartCode();
5038 }
5039 else // normal HTML markup
5040 {
5041 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5042 }
5043 break;
5044 case HtmlTagType::HTML_KBD:
5045 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
5046 break;
5047 case HtmlTagType::HTML_TT:
5048 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
5049 break;
5050 case HtmlTagType::HTML_EMPHASIS:
5051 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
5052 break;
5053 case HtmlTagType::HTML_DIV:
5054 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
5055 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5056 break;
5057 case HtmlTagType::HTML_SPAN:
5058 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
5059 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5060 break;
5061 case HtmlTagType::HTML_SUB:
5062 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
5063 break;
5064 case HtmlTagType::HTML_SUP:
5065 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
5066 break;
5067 case HtmlTagType::HTML_CENTER:
5068 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
5069 break;
5070 case HtmlTagType::HTML_SMALL:
5071 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
5072 break;
5073 case HtmlTagType::HTML_CITE:
5074 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
5075 break;
5076 case HtmlTagType::HTML_PRE:
5077 if (parser()->context.token->emptyTag) break;
5078 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
5079 setInsidePreformatted(TRUE);
5080 parser()->tokenizer.setInsidePre(TRUE);
5081 break;
5082 case HtmlTagType::HTML_P:
5083 retval = Token::make_TK_NEWPARA();
5084 break;
5085 case HtmlTagType::HTML_DL:
5086 if (!parser()->context.token->emptyTag)
5087 {
5088 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
5089 retval=children().get_last<DocHtmlDescList>()->parse();
5090 }
5091 break;
5092 case HtmlTagType::HTML_DT:
5093 if (insideDL(thisVariant()))
5094 {
5095 retval = Token::make_RetVal_DescTitle();
5096 }
5097 else
5098 {
5099 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
5100 }
5101 break;
5102 case HtmlTagType::HTML_DD:
5103 if (insideDL(thisVariant()))
5104 {
5105 retval = Token::make_RetVal_DescData();
5106 }
5107 else
5108 {
5109 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
5110 }
5111 break;
5112 case HtmlTagType::HTML_TABLE:
5113 if (!parser()->context.token->emptyTag)
5114 {
5115 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
5116 retval=children().get_last<DocHtmlTable>()->parse();
5117 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5118 }
5119 break;
5120 case HtmlTagType::HTML_TR:
5121 retval = Token::make_RetVal_TableRow();
5122 break;
5123 case HtmlTagType::HTML_TD:
5124 retval = Token::make_RetVal_TableCell();
5125 break;
5126 case HtmlTagType::HTML_TH:
5127 retval = Token::make_RetVal_TableHCell();
5128 break;
5129 case HtmlTagType::HTML_THEAD:
5130 case HtmlTagType::HTML_TBODY:
5131 case HtmlTagType::HTML_TFOOT:
5132 // for time being ignore </t....> tag
5133 break;
5134 case HtmlTagType::HTML_CAPTION:
5135 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
5136 break;
5137 case HtmlTagType::HTML_BR:
5138 {
5139 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
5140 }
5141 break;
5142 case HtmlTagType::HTML_HR:
5143 {
5144 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
5145 }
5146 break;
5147 case HtmlTagType::HTML_A:
5148 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
5149 break;
5150 case HtmlTagType::HTML_H1:
5151 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
5152 break;
5153 case HtmlTagType::HTML_H2:
5154 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
5155 break;
5156 case HtmlTagType::HTML_H3:
5157 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
5158 break;
5159 case HtmlTagType::HTML_H4:
5160 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
5161 break;
5162 case HtmlTagType::HTML_H5:
5163 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
5164 break;
5165 case HtmlTagType::HTML_H6:
5166 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
5167 break;
5168 case HtmlTagType::HTML_IMG:
5169 {
5170 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
5171 }
5172 break;
5173 case HtmlTagType::HTML_DETAILS:
5174 if (!parser()->context.token->emptyTag)
5175 {
5176 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
5177 retval=children().get_last<DocHtmlDetails>()->parse();
5178 }
5179 break;
5180 case HtmlTagType::HTML_BLOCKQUOTE:
5181 if (!parser()->context.token->emptyTag)
5182 {
5183 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
5184 retval = children().get_last<DocHtmlBlockQuote>()->parse();
5185 }
5186 break;
5187
5188 case HtmlTagType::XML_SUMMARY:
5189 if (insideDetails(thisVariant()))
5190 {
5191 if (!parser()->context.token->emptyTag)
5192 {
5193 DocNodeVariant *n=parent();
5194 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
5195 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
5196 if (d)
5197 {
5198 if (!d->summary()) // details section does not have a summary yet
5199 {
5200 d->parseSummary(n,parser()->context.token->attribs);
5201 }
5202 else
5203 {
5204 retval = Token::make_TK_NEWPARA();
5205 }
5206 }
5207 }
5208 }
5209 break;
5210 case HtmlTagType::XML_REMARKS:
5211 case HtmlTagType::XML_EXAMPLE:
5212 parser()->context.xmlComment=TRUE;
5213 // fall through
5214 case HtmlTagType::XML_VALUE:
5215 case HtmlTagType::XML_PARA:
5216 if (!children().empty())
5217 {
5218 retval = Token::make_TK_NEWPARA();
5219 }
5220 break;
5221 case HtmlTagType::XML_DESCRIPTION:
5222 if (insideTable(thisVariant()))
5223 {
5224 retval = Token::make_RetVal_TableCell();
5225 }
5226 break;
5227 case HtmlTagType::XML_C:
5228 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
5229 break;
5230 case HtmlTagType::XML_PARAM:
5231 case HtmlTagType::XML_TYPEPARAM:
5232 {
5233 parser()->context.xmlComment=TRUE;
5234 QCString paramName;
5235 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5236 {
5237 if (paramName.isEmpty())
5238 {
5239 if (Config_getBool(WARN_NO_PARAMDOC))
5240 {
5241 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5242 }
5243 }
5244 else
5245 {
5246 retval = handleParamSection(paramName,
5247 tagId==HtmlTagType::XML_PARAM ? DocParamSect::Param : DocParamSect::TemplateParam,
5248 TRUE);
5249 }
5250 }
5251 else
5252 {
5253 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5254 }
5255 }
5256 break;
5257 case HtmlTagType::XML_PARAMREF:
5258 case HtmlTagType::XML_TYPEPARAMREF:
5259 {
5260 QCString paramName;
5261 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5262 {
5263 //printf("paramName=%s\n",qPrint(paramName));
5264 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5265 children().append<DocWord>(parser(),thisVariant(),paramName);
5266 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5267 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5268 }
5269 else
5270 {
5271 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5272 }
5273 }
5274 break;
5275 case HtmlTagType::XML_EXCEPTION:
5276 {
5277 parser()->context.xmlComment=TRUE;
5278 QCString exceptName;
5279 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5280 {
5281 unescapeCRef(exceptName);
5282 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5283 }
5284 else
5285 {
5286 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5287 }
5288 }
5289 break;
5290 case HtmlTagType::XML_ITEM:
5291 case HtmlTagType::XML_LISTHEADER:
5292 if (insideTable(thisVariant()))
5293 {
5294 retval = Token::make_RetVal_TableRow();
5295 }
5296 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5297 {
5298 retval = Token::make_RetVal_ListItem();
5299 }
5300 else
5301 {
5302 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5303 }
5304 break;
5305 case HtmlTagType::XML_RETURNS:
5306 parser()->context.xmlComment=TRUE;
5307 retval = handleSimpleSection(DocSimpleSect::Return,TRUE);
5308 parser()->context.hasReturnCommand=TRUE;
5309 break;
5310 case HtmlTagType::XML_TERM:
5311 if (insideTable(thisVariant()))
5312 {
5313 retval = Token::make_RetVal_TableCell();
5314 }
5315 break;
5316 case HtmlTagType::XML_SEE:
5317 // I'm not sure if <see> is the same as <seealso> or if it
5318 // should you link a member without producing a section. The
5319 // C# specification is extremely vague about this (but what else
5320 // can we expect from Microsoft...)
5321 {
5322 QCString cref;
5323 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5324 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5325 {
5326 unescapeCRef(cref);
5327 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5328 {
5329 bool inSeeBlock = parser()->context.inSeeBlock;
5330 parser()->context.token->name = cref;
5331 parser()->context.inSeeBlock = TRUE;
5332 parser()->handleLinkedWord(thisVariant(),children(),TRUE);
5333 parser()->context.inSeeBlock = inSeeBlock;
5334 }
5335 else // <see cref="...">...</see> style
5336 {
5337 parser()->tokenizer.setStatePara();
5338 children().append<DocLink>(parser(),thisVariant(),cref);
5339 DocLink *lnk = children().get_last<DocLink>();
5340 QCString leftOver = lnk->parse(FALSE,TRUE);
5341 if (!leftOver.isEmpty())
5342 {
5343 children().append<DocWord>(parser(),thisVariant(),leftOver);
5344 }
5345 }
5346 }
5347 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5348 {
5349 bool inSeeBlock = parser()->context.inSeeBlock;
5350 parser()->context.token->name = cref;
5351 parser()->context.inSeeBlock = TRUE;
5352 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5353 parser()->handleLinkedWord(thisVariant(),children(),TRUE);
5354 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5355 parser()->context.inSeeBlock = inSeeBlock;
5356 }
5357 else
5358 {
5359 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5360 }
5361 }
5362 break;
5363 case HtmlTagType::XML_SEEALSO:
5364 {
5365 parser()->context.xmlComment=TRUE;
5366 QCString cref;
5367 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5368 {
5369 unescapeCRef(cref);
5370 // Look for an existing "see" section
5371 DocNodeVariant *vss=nullptr;
5372 for (auto &n : children())
5373 {
5374 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5375 if (candidate && candidate->type()==DocSimpleSect::See)
5376 {
5377 vss = &n;
5378 }
5379 }
5380
5381 if (!vss) // start new section
5382 {
5383 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5384 vss = &children().back();
5385 }
5386
5387 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5388 retval = Token::make_RetVal_OK();
5389 }
5390 else
5391 {
5392 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5393 }
5394 }
5395 break;
5396 case HtmlTagType::XML_LIST:
5397 {
5398 QCString type;
5399 findAttribute(tagHtmlAttribs,"type",&type);
5400 DocHtmlList::Type listType = DocHtmlList::Unordered;
5401 HtmlAttribList emptyList;
5402 if (type=="number")
5403 {
5404 listType=DocHtmlList::Ordered;
5405 }
5406 if (type=="table")
5407 {
5408 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5409 retval=children().get_last<DocHtmlTable>()->parseXml();
5410 if (children().get_last<DocHtmlTable>()->children().empty()) children().pop_back();
5411 }
5412 else
5413 {
5414 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5415 retval=children().get_last<DocHtmlList>()->parseXml();
5416 }
5417 }
5418 break;
5419 case HtmlTagType::XML_INCLUDE:
5420 case HtmlTagType::XML_PERMISSION:
5421 // These tags are defined in .Net but are currently unsupported
5422 parser()->context.xmlComment=TRUE;
5423 break;
5424 case HtmlTagType::UNKNOWN:
5425 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5426 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5427 break;
5428 case HtmlTagType::XML_INHERITDOC:
5429 handleInheritDoc();
5430 break;
5431 default:
5432 // we should not get here!
5433 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5434 ASSERT(0);
5435 break;
5436 }
5437 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5438 return retval;
5439}
DocHtmlDetails::parseSummary
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1511
DocHtmlDetails::summary
const DocNodeVariant * summary() const
Definition docnode.h:864
DocPara::handleHtmlHeader
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:4129
DocParser::handleLinkedWord
void handleLinkedWord(DocNodeVariant *parent, DocNodeList &children, bool ignoreAutoLinkFlag=FALSE)
Definition docparser.cpp:784
DocParser::handleAHref
Token handleAHref(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:715
DocParser::handleStyleEnter
void handleStyleEnter(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const QCString &tagName, const HtmlAttribList *attribs)
Definition docparser.cpp:624
DocParser::handleImg
void handleImg(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:1638
DocSimpleSect::type
Type type() const
Definition docnode.h:1026
DocTokenizer::setStateXmlCode
void setStateXmlCode()
Definition doctokenizer.l:1883
GrowVector::back
T & back()
access the last element
Definition growvector.h:135
unescapeCRef
static void unescapeCRef(QCString &s)
Definition docnode.cpp:82
findAttribute
static bool findAttribute(const HtmlAttribList &tagHtmlAttribs, const char *attrName, QCString *result)
Definition docnode.cpp:4955
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 > DocNodeVariant
Definition docnode.h:67
insideTable
bool insideTable(const DocNodeVariant *n)
Definition docparser_p.h:250
insideDL
bool insideDL(const DocNodeVariant *n)
Definition docparser_p.h:274
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 3993 of file docnode.cpp.

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

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), Config_getBool, DocParser::context, DocParserContext::context, DocInclude::DontInclude, DocInclude::DontIncWithLines, DocParserContext::exampleName, DocParserContext::fileName, DocNodeList::get_last(), DocInclude::Include, DocInclude::IncWithLines, Token::is(), Token::is_any_of(), DocParserContext::isExample, DocTokenizer::lex(), TokenInfo::name, parse(), DocNode::parser(), DocTokenizer::setStateBlock(), DocTokenizer::setStateFile(), DocTokenizer::setStateOptions(), DocTokenizer::setStatePara(), DocTokenizer::setStateSnippet(), DocInclude::Snippet, DocInclude::SnippetWithLines, split(), QCString::stripWhiteSpace(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleIncludeOperator()

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

Definition at line 3817 of file docnode.cpp.

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

4184{
4185 if (parser()->context.memberDef) // inheriting docs from a member
4186 {
4187 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4188 if (reMd) // member from which was inherited.
4189 {
4190 const MemberDef *thisMd = parser()->context.memberDef;
4191 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4192 parser()->pushContext();
4193 parser()->context.scope=reMd->getOuterScope();
4194 if (parser()->context.scope!=Doxygen::globalScope)
4195 {
4196 parser()->context.context=parser()->context.scope->name();
4197 }
4198 parser()->context.memberDef=reMd;
4199 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4200 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4201 parser()->context.copyStack.push_back(reMd);
4202 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4203 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4204 parser()->context.copyStack.pop_back();
4205 auto hasParamCommand = parser()->context.hasParamCommand;
4206 auto hasReturnCommand = parser()->context.hasReturnCommand;
4207 auto retvalsFound = parser()->context.retvalsFound;
4208 auto paramsFound = parser()->context.paramsFound;
4209 parser()->popContext();
4210 parser()->context.hasParamCommand = hasParamCommand;
4211 parser()->context.hasReturnCommand = hasReturnCommand;
4212 parser()->context.retvalsFound = retvalsFound;
4213 parser()->context.paramsFound = paramsFound;
4214 parser()->context.memberDef = thisMd;
4215 }
4216 }
4217}
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:1669
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 3916 of file docnode.cpp.

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

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

3472{
3473 AUTO_TRACE();
3474 DocParamSect *ps = nullptr;
3475 if (!children().empty() && // previous element
3476 (ps=children().get_last<DocParamSect>()) && // was a param sect
3477 ps->type()==t) // of same type
3478 { // append to previous section ps
3479 }
3480 else // start new section
3481 {
3482 children().append<DocParamSect>(parser(),thisVariant(),t);
3483 ps = children().get_last<DocParamSect>();
3484 }
3485 Token rv=ps->parse(cmdName,xmlContext,
3486 static_cast<DocParamSect::Direction>(direction));
3487 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3488 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3489}
DocParamSect::parse
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3389
DocParamSect::type
Type type() const
Definition docnode.h:1068

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleRef()

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

Definition at line 3957 of file docnode.cpp.

3958{
3959 AUTO_TRACE("cmdName={}",cmdName);
3960 QCString saveCmdName = cmdName;
3961 Token tok=parser()->tokenizer.lex();
3962 if (!tok.is(TokenRetval::TK_WHITESPACE))
3963 {
3964 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3965 cmdChar,qPrint(saveCmdName));
3966 return;
3967 }
3968 // RAII helper to set and restore state
3969 class AutoRestoreState
3970 {
3971 public:
3972 AutoRestoreState(DocParser *parser) : m_parser(parser) { m_parser->tokenizer.setStateRef(); }
3973 ~AutoRestoreState() { m_parser->tokenizer.setStatePara(); }
3974 private:
3975 DocParser *m_parser;
3976 };
3977 AutoRestoreState rs(parser());
3978 tok=parser()->tokenizer.lex(); // get the reference id
3979 if (!tok.is(TokenRetval::TK_WORD))
3980 {
3981 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3982 tok.to_string(),cmdChar,saveCmdName);
3983 return;
3984 }
3985 {
3986 children().append<DocRef>(parser(),thisVariant(),
3987 parser()->context.token->name,
3988 parser()->context.context);
3989 }
3990 children().get_last<DocRef>()->parse(cmdChar,cmdName);
3991}
qPrint
const char * qPrint(const char *s)
Definition qcstring.h:687

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

Referenced by handleCommand().

◆ handleSection()

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

Definition at line 4098 of file docnode.cpp.

4099{
4100 AUTO_TRACE("cmdName={}",cmdName);
4101 QCString saveCmdName = cmdName;
4102 // get the argument of the section command.
4103 Token tok=parser()->tokenizer.lex();
4104 if (!tok.is(TokenRetval::TK_WHITESPACE))
4105 {
4106 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4107 cmdChar,saveCmdName);
4108 return;
4109 }
4110 tok=parser()->tokenizer.lex();
4111 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4112 {
4113 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4114 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4115 return;
4116 }
4117 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4118 {
4119 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4120 tok.to_string(),cmdChar,saveCmdName);
4121 return;
4122 }
4123 parser()->context.token->sectionId = parser()->context.token->name;
4124 parser()->tokenizer.setStateSkipTitle();
4125 parser()->tokenizer.lex();
4126 parser()->tokenizer.setStatePara();
4127}
DocTokenizer::setStateSkipTitle
void setStateSkipTitle()
Definition doctokenizer.l:2085

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

3748{
3749 AUTO_TRACE();
3750 QCString fmt;
3751 QCString date;
3752 Token tok=parser()->tokenizer.lex();
3753 if (!tok.is(TokenRetval::TK_WHITESPACE))
3754 {
3755 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3756 cmdChar,cmdName);
3757 return;
3758 }
3759 parser()->tokenizer.setStateQuotedString();
3760 tok = parser()->tokenizer.lex();
3761 if (!tok.is(TokenRetval::TK_WORD))
3762 {
3763 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3764 cmdChar,cmdName);
3765 parser()->tokenizer.setStatePara();
3766 return;
3767 }
3768 fmt = parser()->context.token->name;
3769
3770 parser()->tokenizer.setStateShowDate();
3771 tok = parser()->tokenizer.lex();
3772
3773 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3774 QCString specDate = specDateRaw.stripWhiteSpace();
3775 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3776 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3777 {
3778 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3779 cmdChar,cmdName);
3780 parser()->tokenizer.setStatePara();
3781 return;
3782 }
3783
3784 std::tm dat{};
3785 int specFormat=0;
3786 QCString err = dateTimeFromString(specDate,dat,specFormat);
3787 if (!err.isEmpty())
3788 {
3789 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3790 cmdChar,cmdName,err);
3791 parser()->tokenizer.setStatePara();
3792 return;
3793 }
3794
3795 int usedFormat=0;
3796 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3797
3798 // warn the user if the format contains markers that are not explicitly filled in
3799 for (int i=0;i<SF_NumBits;i++)
3800 {
3801 int bitMask = 1<<i;
3802 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3803 {
3804 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.",
3805 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3806 }
3807 }
3808
3809 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3810 if (specDateOnlyWS) // specDate is only whitespace
3811 {
3812 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3813 }
3814 parser()->tokenizer.setStatePara();
3815}
DocTokenizer::setStateShowDate
void setStateShowDate()
Definition doctokenizer.l:2159
DocTokenizer::setStateQuotedString
void setStateQuotedString()
Definition doctokenizer.l:2152
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 3438 of file docnode.cpp.

3439{
3440 AUTO_TRACE();
3441 DocSimpleSect *ss=nullptr;
3442 bool needsSeparator = FALSE;
3443 if (!children().empty() && // has previous element
3444 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3445 ss->type()==t && // of same type
3446 t!=DocSimpleSect::User) // but not user defined
3447 {
3448 // append to previous section
3449 needsSeparator = TRUE;
3450 }
3451 else // start new section
3452 {
3453 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3454 ss = children().get_last<DocSimpleSect>();
3455 }
3456 Token rv = Token::make_RetVal_OK();
3457 if (xmlContext)
3458 {
3459 return ss->parseXml();
3460 }
3461 else
3462 {
3463 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3464 }
3465 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3466}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3102
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:3156

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

4148{
4149 AUTO_TRACE();
4150 Token retval = parser()->tokenizer.lex();
4151 QCString lang = parser()->context.token->name;
4152 if (!lang.isEmpty() && lang.at(0)!='.')
4153 {
4154 lang="."+lang;
4155 }
4156 if (parser()->context.xmlComment)
4157 {
4158 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4159 }
4160 // search for the first non-whitespace line, index is stored in li
4161 size_t i=0,li=0,l=parser()->context.token->verb.length();
4162 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4163 {
4164 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4165 i++;
4166 }
4167 children().append<DocVerbatim>(parser(),thisVariant(),
4168 parser()->context.context,
4169 stripIndentation(parser()->context.token->verb.mid(li)),
4170 DocVerbatim::Code,
4171 parser()->context.isExample,
4172 parser()->context.exampleName,
4173 FALSE,lang);
4174 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4175 {
4176 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4177 }
4178 parser()->tokenizer.setStatePara();
4179 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4180 return retval;
4181}
QCString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
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:5949

References DocNodeList::append(), QCString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), DocVerbatim::Code, DocParser::context, DocParserContext::context, DocParserContext::exampleName, FALSE, Token::is_any_of(), QCString::isEmpty(), DocParserContext::isExample, QCString::length(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), stripIndentation(), substitute(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TokenInfo::verb, and warn_doc_error.

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleVhdlFlow()

void DocPara::handleVhdlFlow ( )

Definition at line 3909 of file docnode.cpp.

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

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

Referenced by handleCommand().

◆ handleXRefItem()

Token DocPara::handleXRefItem ( )

Definition at line 3725 of file docnode.cpp.

3726{
3727 AUTO_TRACE();
3728 Token retval=parser()->tokenizer.lex();
3729 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3730 parser()->tokenizer.setStateXRefItem();
3731 retval=parser()->tokenizer.lex();
3732 if (retval.is(TokenRetval::RetVal_OK))
3733 {
3734 children().append<DocXRefItem>(parser(),thisVariant(),
3735 parser()->context.token->id,parser()->context.token->name);
3736 DocXRefItem *ref = children().get_last<DocXRefItem>();
3737 if (!ref->parse())
3738 {
3739 children().pop_back();
3740 }
3741 }
3742 parser()->tokenizer.setStatePara();
3743 return retval;
3744}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2013

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

4141{
4142 AUTO_TRACE();
4143 parser()->context.token->name = tokText;
4144 return parser()->defaultHandleToken(thisVariant(),tok,children());
4145}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token tok, DocNodeList &children, bool handleWord=TRUE)
Definition docparser.cpp:1269

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

Referenced by DocSimpleSect::appendLinkWord().

◆ isEmpty()

bool DocPara::isEmpty ( ) const
inline

Definition at line 1084 of file docnode.h.

1084{ return children().empty(); }
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 1087 of file docnode.h.

1087{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1088 of file docnode.h.

1088{ 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 1085 of file docnode.h.

1085{ 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 1086 of file docnode.h.

1086{ 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 5714 of file docnode.cpp.

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

◆ setAttribs()

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

Definition at line 1113 of file docnode.h.

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

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1118 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1116 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1117 of file docnode.h.

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

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