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

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 empty () const
void markFirst (bool v=true)
void markLast (bool v=true)
bool isFirst () const
bool isLast () const
Token handleCommand (char cmdChar, const DString &cmdName)
Token handleHtmlStartTag (const DString &tagName, const HtmlAttribList &tagHtmlAttribs)
Token handleHtmlEndTag (const DString &tagName)
Token handleSimpleSection (DocSimpleSect::Type t, bool xmlContext=false)
Token handleXRefItem ()
Token handleParamSection (const DString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
void handleIncludeOperator (const DString &cmdName, DocIncOperator::Type t)
template<class T>
void handleFile (const DString &cmdName)
void handleInclude (const DString &cmdName, DocInclude::Type t)
void handleLink (const DString &cmdName, bool isJavaLink)
void handleDoxyConfig (char cmdChar, const DString &cmdName)
void handleEmoji (char cmdChar, const DString &cmdName)
void handleSection (char cmdChar, const DString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void handleShowDate (char cmdChar, const DString &cmdName)
Token handleStartCode ()
Token handleHtmlHeader (const HtmlAttribList &tagHtmlAttribs, int level)
bool injectToken (Token tok, const DString &tokText)
const HtmlAttribList & attribs () const
void setAttribs (const HtmlAttribList &attribs)
Public Member Functions inherited from DocCompoundNode
 DocCompoundNode (DocParser *parser, DocNodeVariant *parent)
DocNodeList & children ()
const DocNodeList & children () const
Public Member Functions inherited from DocNode
 DocNode (DocParser *parser, DocNodeVariant *parent)
 ~DocNode ()=default
DocNodeVariant * parent ()
const DocNodeVariant * parent () const
DocNodeVariant * thisVariant ()
const DocNodeVariant * thisVariant () const
void setThisVariant (DocNodeVariant *thisVariant)
DocParser * parser ()
const DocParser * parser () const
void setParent (DocNodeVariant *parent)
bool isPreformatted () const

Private Attributes

bool m_isFirst = false
bool m_isLast = false
HtmlAttribList m_attribs

Additional Inherited Members

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

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1088 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3575 of file docnode.cpp.

3575 :
3576 DocCompoundNode(parser,parent),
3577 m_isFirst(false), m_isLast(false)
3578{
3579}
DocCompoundNode::DocCompoundNode
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:141
DocNode::parser
DocParser * parser()
Definition docnode.h:97
DocNode::parent
DocNodeVariant * parent()
Definition docnode.h:89
DocPara::m_isFirst
bool m_isFirst
Definition docnode.h:1123
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1124

References DocCompoundNode::DocCompoundNode(), 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 1119 of file docnode.h.

1119{ return m_attribs; }
DocPara::m_attribs
HtmlAttribList m_attribs
Definition docnode.h:1125

References m_attribs.

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

◆ empty()

bool DocPara::empty ( ) const
inline

Definition at line 1093 of file docnode.h.

1093{ return children().empty(); }
DocCompoundNode::children
DocNodeList & children()
Definition docnode.h:143
GrowVector::empty
bool empty() const
checks whether the container is empty
Definition growvector.h:140

References DocCompoundNode::children(), and GrowVector< T >::empty().

Referenced by handleHtmlStartTag(), handleParamSection(), handleSimpleSection(), and parse().

◆ handleCommand()

Token DocPara::handleCommand ( char cmdChar,
const DString & cmdName )

Definition at line 4226 of file docnode.cpp.

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

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

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3665 of file docnode.cpp.

3666{
3667 // get the argument of the cite command.
3668 Token tok=parser()->tokenizer.lex();
3669 if (!tok.is(TokenRetval::TK_WHITESPACE))
3670 {
3671 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3672 cmdChar,cmdName);
3673 return;
3674 }
3675 parser()->tokenizer.setStateDoxyConfig();
3676 tok=parser()->tokenizer.lex();
3677 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3678 {
3679 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3680 "argument of command '{:c}{}'",cmdChar,cmdName);
3681 return;
3682 }
3683 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3684 {
3685 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3686 tok.to_string(),cmdChar,cmdName);
3687 return;
3688 }
3689 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3690 if (opt)
3691 {
3692 DString optionValue;
3693 switch (opt->kind())
3694 {
3695 case ConfigOption::O_Bool:
3696 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3697 break;
3698 case ConfigOption::O_String:
3699 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3700 break;
3701 case ConfigOption::O_Enum:
3702 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3703 break;
3704 case ConfigOption::O_Int:
3705 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3706 break;
3707 case ConfigOption::O_List:
3708 {
3709 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3710 optionValue="";
3711 if (!lst->empty())
3712 {
3713 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3714 static const reg::Ex marker(R"(@(\d+))");
3715 reg::Iterator it(lstFormat,marker);
3716 reg::Iterator end;
3717 size_t index=0;
3718 // now replace all markers with the real text
3719 for ( ; it!=end ; ++it)
3720 {
3721 const auto &match = *it;
3722 size_t newIndex = match.position();
3723 size_t matchLen = match.length();
3724 optionValue += lstFormat.substr(index,newIndex-index);
3725 unsigned long entryIndex = std::stoul(match[1].str());
3726 if (entryIndex<(unsigned long)lst->size())
3727 {
3728 optionValue += lst->at(entryIndex);
3729 }
3730 index=newIndex+matchLen;
3731 }
3732 optionValue+=lstFormat.substr(index);
3733 }
3734 }
3735 break;
3736 case ConfigOption::O_Obsolete:
3737 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3738 cmdChar,cmdName,parser()->context.token->name);
3739 break;
3740 case ConfigOption::O_Disabled:
3741 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3742 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3743 cmdChar,cmdName,parser()->context.token->name);
3744 break;
3745 case ConfigOption::O_Info:
3746 // nothing to show here
3747 break;
3748 }
3749 if (!optionValue.empty())
3750 {
3751 children().append<DocWord>(parser(),thisVariant(),optionValue);
3752 }
3753 }
3754 else
3755 {
3756 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3757 cmdChar,cmdName,parser()->context.token->name);
3758 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3759 }
3760 parser()->tokenizer.setStatePara();
3761}
ConfigImpl::instance
static ConfigImpl * instance()
Definition configimpl.h:347
ConfigImpl::get
ConfigOption * get(const DString &name) const
Definition configimpl.h:396
ConfigOption::O_Disabled
@ O_Disabled
Disabled compile time option.
Definition configimpl.h:51
ConfigOption::O_List
@ O_List
A list of items.
Definition configimpl.h:45
ConfigOption::O_Enum
@ O_Enum
A fixed set of items.
Definition configimpl.h:46
ConfigOption::O_Bool
@ O_Bool
A boolean value.
Definition configimpl.h:49
ConfigOption::O_String
@ O_String
A single item.
Definition configimpl.h:47
ConfigOption::O_Obsolete
@ O_Obsolete
An obsolete option.
Definition configimpl.h:50
ConfigOption::O_Int
@ O_Int
An integer value.
Definition configimpl.h:48
ConfigOption::O_Info
@ O_Info
A section header.
Definition configimpl.h:44
ConfigOption::kind
OptionType kind() const
Definition configimpl.h:66
DString::substr
DString substr(size_t pos=0, size_t count=npos) const
Returns a substring of length count starting at pos.
Definition dstring.h:223
DocTokenizer::setStateDoxyConfig
void setStateDoxyConfig()
Definition doctokenizer.l:2129
Token::is
bool is(TokenRetval rv) const
Definition doctokenizer.h:119
Token::to_string
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
Definition doctokenizer.h:90
Token::is_any_of
bool is_any_of(ARGS... args) const
Definition doctokenizer.h:114
Translator::trWriteList
virtual DString trWriteList(int numEntries)=0
end
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:181
theTranslator
Translator * theTranslator
Definition language.cpp:76
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:861

References DocNodeList::append(), DocCompoundNode::children(), DocParser::context, DString::empty(), end(), ConfigImpl::get(), ConfigImpl::instance(), Token::is(), Token::is_any_of(), 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(), DString::str(), DString::substr(), theTranslator, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Translator::trWriteList(), ConfigEnum::valueRef(), ConfigString::valueRef(), ConfigBool::valueStringRef(), ConfigInt::valueStringRef(), warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleEmoji()

void DocPara::handleEmoji ( char cmdChar,
const DString & cmdName )

Definition at line 3634 of file docnode.cpp.

3635{
3636 AUTO_TRACE();
3637 // get the argument of the emoji command.
3638 Token tok=parser()->tokenizer.lex();
3639 if (!tok.is(TokenRetval::TK_WHITESPACE))
3640 {
3641 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3642 cmdChar,cmdName);
3643 return;
3644 }
3645 parser()->tokenizer.setStateEmoji();
3646 tok=parser()->tokenizer.lex();
3647 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3648 {
3649 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3650 "argument of command '{:c}{}'",cmdChar,cmdName);
3651 parser()->tokenizer.setStatePara();
3652 return;
3653 }
3654 else if (!tok.is(TokenRetval::TK_WORD))
3655 {
3656 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3657 tok.to_string(),cmdChar,cmdName);
3658 parser()->tokenizer.setStatePara();
3659 return;
3660 }
3661 children().append<DocEmoji>(parser(),thisVariant(),parser()->context.token->name);
3662 parser()->tokenizer.setStatePara();
3663}
DocTokenizer::setStateEmoji
void setStateEmoji()
Definition doctokenizer.l:2210

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 DString & cmdName)

Definition at line 3915 of file docnode.cpp.

3916{
3917 AUTO_TRACE("cmdName={}",cmdName);
3918 DString saveCmdName = cmdName;
3919 Token tok=parser()->tokenizer.lex();
3920 if (!tok.is(TokenRetval::TK_WHITESPACE))
3921 {
3922 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3923 saveCmdName);
3924 return;
3925 }
3926 parser()->tokenizer.setStateFile();
3927 tok=parser()->tokenizer.lex();
3928 parser()->tokenizer.setStatePara();
3929 if (!tok.is(TokenRetval::TK_WORD))
3930 {
3931 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3932 tok.to_string(),saveCmdName);
3933 return;
3934 }
3935 DString name = parser()->context.token->name;
3936 children().append<T>(parser(),thisVariant(),name,
3937 parser()->context.context,
3938 parser()->context.fileName,
3939 parser()->tokenizer.getLineNr());
3940 auto df = children().get_last<T>();
3941 if (!df->parse())
3942 {
3943 children().pop_back();
3944 }
3945}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2093
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2302

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 DString & tagName)

Definition at line 5506 of file docnode.cpp.

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

References DocNodeList::append(), ASSERT, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, DocStyleChange::Del, DocStyleChange::Div, 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 4131 of file docnode.cpp.

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

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

Referenced by handleHtmlStartTag().

◆ handleHtmlStartTag()

Token DocPara::handleHtmlStartTag ( const DString & tagName,
const HtmlAttribList & tagHtmlAttribs )

Definition at line 5036 of file docnode.cpp.

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

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, empty(), DString::empty(), DocParamSect::Exception, 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(), 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, 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 DString & cmdName,
DocInclude::Type t )

Definition at line 3995 of file docnode.cpp.

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

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(), DString::stripWhiteSpace(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleIncludeOperator()

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

Definition at line 3855 of file docnode.cpp.

3856{
3857 AUTO_TRACE("cmdName={}",cmdName);
3858 DString saveCmdName = cmdName;
3859 Token tok=parser()->tokenizer.lex();
3860 if (!tok.is(TokenRetval::TK_WHITESPACE))
3861 {
3862 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3863 saveCmdName);
3864 return;
3865 }
3866 parser()->tokenizer.setStatePattern();
3867 tok=parser()->tokenizer.lex();
3868 parser()->tokenizer.setStatePara();
3869 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3870 {
3871 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3872 "argument of command {}", saveCmdName);
3873 return;
3874 }
3875 else if (!tok.is(TokenRetval::TK_WORD))
3876 {
3877 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3878 tok.to_string(),saveCmdName);
3879 return;
3880 }
3881 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3882 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3883 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3884 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3885 //TODO get from context the stripCodeComments()
3886 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3887 children().append<DocIncOperator>(parser(),thisVariant(),t,
3888 parser()->context.token->name,
3889 parser()->context.context,
3890 stripCodeComments,
3891 parser()->context.isExample,
3892 parser()->context.exampleName
3893 );
3894 DocIncOperator *op = children().get_last<DocIncOperator>();
3895 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3896 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3897 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3898 bool isFirst = !n1 || // no last node
3899 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3900 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3901 op->markFirst(isFirst);
3902 op->markLast(true);
3903 if (n1_docIncOp)
3904 {
3905 n1_docIncOp->markLast(false);
3906 }
3907 else if (n1_docWs && n2_docIncOp)
3908 {
3909 n2_docIncOp->markLast(false);
3910 }
3911 op->parse();
3912}
DocIncOperator::markLast
void markLast(bool v=true)
Definition docnode.h:505
DocPara::isFirst
bool isFirst() const
Definition docnode.h:1096
DocTokenizer::setStatePattern
void setStatePattern()
Definition doctokenizer.l:2107
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 4185 of file docnode.cpp.

4186{
4187 if (parser()->context.memberDef) // inheriting docs from a member
4188 {
4189 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4190 if (reMd) // member from which was inherited.
4191 {
4192 const MemberDef *thisMd = parser()->context.memberDef;
4193 bool hasParamCommand = false;
4194 bool hasReturnCommand = false;
4195 StringMultiSet retvalsFound;
4196 StringMultiSet paramsFound;
4197 { DocParser::AutoSaveContext saveContext(*parser());
4198 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4199 parser()->context.scope=reMd->getOuterScope();
4200 if (parser()->context.scope!=Doxygen::globalScope)
4201 {
4202 parser()->context.context=parser()->context.scope->name();
4203 }
4204 parser()->context.memberDef=reMd;
4205 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4206 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4207 parser()->context.copyStack.push_back(reMd);
4208 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4209 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4210 parser()->context.copyStack.pop_back();
4211 hasParamCommand = parser()->context.hasParamCommand;
4212 hasReturnCommand = parser()->context.hasReturnCommand;
4213 retvalsFound = parser()->context.retvalsFound;
4214 paramsFound = parser()->context.paramsFound;
4215 }
4216 parser()->context.hasParamCommand = hasParamCommand;
4217 parser()->context.hasReturnCommand = hasReturnCommand;
4218 parser()->context.retvalsFound = retvalsFound;
4219 parser()->context.paramsFound = paramsFound;
4220 parser()->context.memberDef = thisMd;
4221 }
4222 }
4223}
Definition::briefDescription
virtual DString briefDescription(bool abbreviate=false) const =0
Definition::documentation
virtual DString documentation() const =0
Definition::name
virtual const DString & name() const =0
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
DocParser::internalValidatingParseDoc
Token internalValidatingParseDoc(DocNodeVariant *parent, DocNodeList &children, const DString &doc)
Definition docparser.cpp:1888
MemberDef::reimplements
virtual const MemberDef * reimplements() const =0
StringMultiSet
std::multiset< std::string > StringMultiSet
Definition containers.h:32
DocParserContext::retvalsFound
StringMultiSet retvalsFound
Definition docparser_p.h:75
DocParserContext::styleStack
DocStyleChangeStack styleStack
Definition docparser_p.h:67
DocParserContext::paramsFound
StringMultiSet paramsFound
Definition docparser_p.h:76
DocParserContext::copyStack
DefinitionStack copyStack
Definition docparser_p.h:69

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleLink()

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

Definition at line 3954 of file docnode.cpp.

3955{
3956 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3957 DString saveCmdName = cmdName;
3958 Token tok=parser()->tokenizer.lex();
3959 if (!tok.is(TokenRetval::TK_WHITESPACE))
3960 {
3961 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3962 saveCmdName);
3963 return;
3964 }
3965 parser()->tokenizer.setStateLink();
3966 tok=parser()->tokenizer.lex();
3967 if (!tok.is(TokenRetval::TK_WORD))
3968 {
3969 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3970 tok.to_string(),saveCmdName);
3971 return;
3972 }
3973 if (saveCmdName == "javalink")
3974 {
3975 children().append<DocStyleChange>(parser(),thisVariant(),
3976 parser()->context.nodeStack.size(),
3977 DocStyleChange::Code,cmdName,true);
3978 }
3979 parser()->tokenizer.setStatePara();
3980 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3981 DocLink *lnk = children().get_last<DocLink>();
3982 if (saveCmdName == "javalink")
3983 {
3984 children().append<DocStyleChange>(parser(),thisVariant(),
3985 parser()->context.nodeStack.size(),
3986 DocStyleChange::Code,cmdName,false);
3987 }
3988 DString leftOver = lnk->parse(isJavaLink);
3989 if (!leftOver.empty())
3990 {
3991 children().append<DocWord>(parser(),thisVariant(),leftOver);
3992 }
3993}
DocTokenizer::setStateLink
void setStateLink()
Definition doctokenizer.l:2115

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocStyleChange::Code, DocParser::context, DString::empty(), DocNodeList::get_last(), Token::is(), DocTokenizer::lex(), TokenInfo::name, DocParserContext::nodeStack, DocNode::parser(), DocTokenizer::setStateLink(), DocTokenizer::setStatePara(), DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleParamSection()

Token DocPara::handleParamSection ( const DString & cmdName,
DocParamSect::Type t,
bool xmlContext = false,
int direction = DocParamSect::Unspecified )

Definition at line 3611 of file docnode.cpp.

3615{
3616 AUTO_TRACE();
3617 DocParamSect *ps = nullptr;
3618 if (!children().empty() && // previous element
3619 (ps=children().get_last<DocParamSect>()) && // was a param sect
3620 ps->type()==t) // of same type
3621 { // append to previous section ps
3622 }
3623 else // start new section
3624 {
3625 children().append<DocParamSect>(parser(),thisVariant(),t);
3626 ps = children().get_last<DocParamSect>();
3627 }
3628 Token rv=ps->parse(cmdName,xmlContext,
3629 static_cast<DocParamSect::Direction>(direction));
3630 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3631 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3632}
DocParamSect::parse
Token parse(const DString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3532
DocParamSect::type
Type type() const
Definition docnode.h:1077

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleSection()

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

Definition at line 4100 of file docnode.cpp.

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

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 DString & cmdName )

Definition at line 3785 of file docnode.cpp.

3786{
3787 AUTO_TRACE();
3788 DString fmt;
3789 DString date;
3790 Token tok=parser()->tokenizer.lex();
3791 if (!tok.is(TokenRetval::TK_WHITESPACE))
3792 {
3793 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3794 cmdChar,cmdName);
3795 return;
3796 }
3797 parser()->tokenizer.setStateQuotedString();
3798 tok = parser()->tokenizer.lex();
3799 if (!tok.is(TokenRetval::TK_WORD))
3800 {
3801 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3802 cmdChar,cmdName);
3803 parser()->tokenizer.setStatePara();
3804 return;
3805 }
3806 fmt = parser()->context.token->name;
3807
3808 parser()->tokenizer.setStateShowDate();
3809 tok = parser()->tokenizer.lex();
3810
3811 DString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : DString();
3812 DString specDate = specDateRaw.stripWhiteSpace();
3813 bool specDateOnlyWS = !specDateRaw.empty() && specDate.empty();
3814 if (!specDate.empty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3815 {
3816 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3817 cmdChar,cmdName);
3818 parser()->tokenizer.setStatePara();
3819 return;
3820 }
3821
3822 std::tm dat{};
3823 int specFormat=0;
3824 DString err = dateTimeFromString(specDate,dat,specFormat);
3825 if (!err.empty())
3826 {
3827 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3828 cmdChar,cmdName,err);
3829 parser()->tokenizer.setStatePara();
3830 return;
3831 }
3832
3833 int usedFormat=0;
3834 DString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3835
3836 // warn the user if the format contains markers that are not explicitly filled in
3837 for (int i=0;i<SF_NumBits;i++)
3838 {
3839 int bitMask = 1<<i;
3840 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3841 {
3842 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.",
3843 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3844 }
3845 }
3846
3847 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3848 if (specDateOnlyWS) // specDate is only whitespace
3849 {
3850 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3851 }
3852 parser()->tokenizer.setStatePara();
3853}
DocTokenizer::setStateShowDate
void setStateShowDate()
Definition doctokenizer.l:2232
DocTokenizer::setStateQuotedString
void setStateQuotedString()
Definition doctokenizer.l:2225
formatDateTime
DString formatDateTime(const DString &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:176
dateTimeFromString
DString dateTimeFromString(const DString &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:135
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(), DString::empty(), err, formatDateTime(), Token::is(), Token::is_any_of(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), DocTokenizer::setStateQuotedString(), DocTokenizer::setStateShowDate(), SF_bit2str(), SF_NumBits, DString::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 3581 of file docnode.cpp.

3582{
3583 AUTO_TRACE();
3584 DocSimpleSect *ss=nullptr;
3585 bool needsSeparator = false;
3586 if (!children().empty() && // has previous element
3587 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3588 ss->type()==t && // of same type
3589 t!=DocSimpleSect::User) // but not user defined
3590 {
3591 // append to previous section
3592 needsSeparator = true;
3593 }
3594 else // start new section
3595 {
3596 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3597 ss = children().get_last<DocSimpleSect>();
3598 }
3599 Token rv = Token::make_RetVal_OK();
3600 if (xmlContext)
3601 {
3602 return ss->parseXml();
3603 }
3604 else
3605 {
3606 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3607 }
3608 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3609}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3244
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:3298

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), empty(), DocNodeList::get_last(), Token::is(), DocSimpleSect::parse(), DocNode::parser(), DocSimpleSect::parseXml(), DocNode::thisVariant(), DocSimpleSect::type(), and DocSimpleSect::User.

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 4149 of file docnode.cpp.

4150{
4151 AUTO_TRACE();
4152 Token retval = parser()->tokenizer.lex();
4153 DString lang = parser()->context.token->name;
4154 if (!lang.empty() && lang.at(0)!='.')
4155 {
4156 lang="."+lang;
4157 }
4158 if (parser()->context.xmlComment)
4159 {
4160 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4161 }
4162 // search for the first non-whitespace line, index is stored in li
4163 size_t i=0,li=0,l=parser()->context.token->verb.length();
4164 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4165 {
4166 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4167 i++;
4168 }
4169 children().append<DocVerbatim>(parser(),thisVariant(),
4170 parser()->context.context,
4171 stripIndentation(parser()->context.token->verb.mid(li)),
4172 DocVerbatim::Code,
4173 parser()->context.isExample,
4174 parser()->context.exampleName,
4175 false,lang);
4176 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4177 {
4178 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4179 }
4180 parser()->tokenizer.setStatePara();
4181 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4182 return retval;
4183}
DString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition dstring.h:686
DString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition dstring.h:151
substitute
DString substitute(const DString &s, const DString &src, const DString &dst)
substitute all occurrences of src in s by dst
Definition dstring.cpp:485
stripIndentation
DString stripIndentation(const DString &s, bool skipFirstLine)
Definition util.cpp:4684

References DocNodeList::append(), DString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), DocVerbatim::Code, DocParser::context, DocParserContext::context, DString::empty(), DocParserContext::exampleName, Token::is_any_of(), DocParserContext::isExample, DString::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 3947 of file docnode.cpp.

3948{
3949 AUTO_TRACE();
3950 children().append<DocVhdlFlow>(parser(),thisVariant());
3951 children().get_last<DocVhdlFlow>()->parse();
3952}

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

3764{
3765 AUTO_TRACE();
3766 Token retval=parser()->tokenizer.lex();
3767 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3768 parser()->tokenizer.setStateXRefItem();
3769 retval=parser()->tokenizer.lex();
3770 if (retval.is(TokenRetval::RetVal_OK))
3771 {
3772 children().append<DocXRefItem>(parser(),thisVariant(),
3773 parser()->context.token->id,parser()->context.token->name);
3774 DocXRefItem *ref = children().get_last<DocXRefItem>();
3775 if (!ref->parse())
3776 {
3777 children().pop_back();
3778 }
3779 }
3780 parser()->tokenizer.setStatePara();
3781 return retval;
3782}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2086

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 DString & tokText )

Definition at line 4142 of file docnode.cpp.

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

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

Referenced by DocSimpleSect::appendLinkWord().

◆ isFirst()

bool DocPara::isFirst ( ) const
inline

Definition at line 1096 of file docnode.h.

1096{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1097 of file docnode.h.

1097{ return m_isLast; }

References m_isLast.

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

◆ markFirst()

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

Definition at line 1094 of file docnode.h.

1094{ m_isFirst=v; }

References m_isFirst.

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

◆ markLast()

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

Definition at line 1095 of file docnode.h.

1095{ m_isLast=v; }

References m_isLast.

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

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

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(), empty(), 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(), DString::mid(), TokenInfo::name, DocNode::parent(), parse(), DocNode::parser(), DocSimpleSect::Rcs, setAttribs(), SIMPLESECT_BIT, TokenInfo::simpleSectName, TokenInfo::simpleSectText, HtmlEntityMapper::Sym_Unknown, TokenInfo::text, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Token::value(), and warn_doc_error.

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

◆ setAttribs()

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

Definition at line 1120 of file docnode.h.

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

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1125 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1123 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1124 of file docnode.h.

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

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