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

3565 :
3566 DocCompoundNode(parser,parent),
3567 m_isFirst(false), m_isLast(false)
3568{
3569}
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 4216 of file docnode.cpp.

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

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

3656{
3657 // get the argument of the cite command.
3658 Token tok=parser()->tokenizer.lex();
3659 if (!tok.is(TokenRetval::TK_WHITESPACE))
3660 {
3661 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3662 cmdChar,cmdName);
3663 return;
3664 }
3665 parser()->tokenizer.setStateDoxyConfig();
3666 tok=parser()->tokenizer.lex();
3667 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3668 {
3669 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3670 "argument of command '{:c}{}'",cmdChar,cmdName);
3671 return;
3672 }
3673 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3674 {
3675 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3676 tok.to_string(),cmdChar,cmdName);
3677 return;
3678 }
3679 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3680 if (opt)
3681 {
3682 DString optionValue;
3683 switch (opt->kind())
3684 {
3685 case ConfigOption::O_Bool:
3686 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3687 break;
3688 case ConfigOption::O_String:
3689 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3690 break;
3691 case ConfigOption::O_Enum:
3692 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3693 break;
3694 case ConfigOption::O_Int:
3695 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3696 break;
3697 case ConfigOption::O_List:
3698 {
3699 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3700 optionValue="";
3701 if (!lst->empty())
3702 {
3703 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3704 static const reg::Ex marker(R"(@(\d+))");
3705 reg::Iterator it(lstFormat,marker);
3706 reg::Iterator end;
3707 size_t index=0;
3708 // now replace all markers with the real text
3709 for ( ; it!=end ; ++it)
3710 {
3711 const auto &match = *it;
3712 size_t newIndex = match.position();
3713 size_t matchLen = match.length();
3714 optionValue += lstFormat.substr(index,newIndex-index);
3715 unsigned long entryIndex = std::stoul(match[1].str());
3716 if (entryIndex<(unsigned long)lst->size())
3717 {
3718 optionValue += lst->at(entryIndex);
3719 }
3720 index=newIndex+matchLen;
3721 }
3722 optionValue+=lstFormat.substr(index);
3723 }
3724 }
3725 break;
3726 case ConfigOption::O_Obsolete:
3727 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3728 cmdChar,cmdName,parser()->context.token->name);
3729 break;
3730 case ConfigOption::O_Disabled:
3731 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3732 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3733 cmdChar,cmdName,parser()->context.token->name);
3734 break;
3735 case ConfigOption::O_Info:
3736 // nothing to show here
3737 break;
3738 }
3739 if (!optionValue.empty())
3740 {
3741 children().append<DocWord>(parser(),thisVariant(),optionValue);
3742 }
3743 }
3744 else
3745 {
3746 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3747 cmdChar,cmdName,parser()->context.token->name);
3748 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3749 }
3750 parser()->tokenizer.setStatePara();
3751}
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:2119
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 3624 of file docnode.cpp.

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

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

3906{
3907 AUTO_TRACE("cmdName={}",cmdName);
3908 DString saveCmdName = cmdName;
3909 Token tok=parser()->tokenizer.lex();
3910 if (!tok.is(TokenRetval::TK_WHITESPACE))
3911 {
3912 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3913 saveCmdName);
3914 return;
3915 }
3916 parser()->tokenizer.setStateFile();
3917 tok=parser()->tokenizer.lex();
3918 parser()->tokenizer.setStatePara();
3919 if (!tok.is(TokenRetval::TK_WORD))
3920 {
3921 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3922 tok.to_string(),saveCmdName);
3923 return;
3924 }
3925 DString name = parser()->context.token->name;
3926 children().append<T>(parser(),thisVariant(),name,
3927 parser()->context.context,
3928 parser()->context.fileName,
3929 parser()->tokenizer.getLineNr());
3930 auto df = children().get_last<T>();
3931 if (!df->parse())
3932 {
3933 children().pop_back();
3934 }
3935}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2083
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2292

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

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

4122{
4123 AUTO_TRACE();
4124 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4125 Token retval = children().get_last<DocHtmlHeader>()->parse();
4126 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4127}

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

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

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

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), Config_getBool, DocParser::context, DocParserContext::context, DocInclude::DontInclude, DocInclude::DontIncWithLines, DocParserContext::exampleName, DocParserContext::fileName, DocNodeList::get_last(), DocInclude::Include, DocInclude::IncWithLines, Token::is(), Token::is_any_of(), DocParserContext::isExample, DocTokenizer::lex(), TokenInfo::name, parse(), DocNode::parser(), DocTokenizer::setStateBlock(), DocTokenizer::setStateFile(), DocTokenizer::setStateOptions(), DocTokenizer::setStatePara(), DocTokenizer::setStateSnippet(), DocInclude::Snippet, DocInclude::SnippetWithLines, split(), 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 3845 of file docnode.cpp.

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

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

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

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

3605{
3606 AUTO_TRACE();
3607 DocParamSect *ps = nullptr;
3608 if (!children().empty() && // previous element
3609 (ps=children().get_last<DocParamSect>()) && // was a param sect
3610 ps->type()==t) // of same type
3611 { // append to previous section ps
3612 }
3613 else // start new section
3614 {
3615 children().append<DocParamSect>(parser(),thisVariant(),t);
3616 ps = children().get_last<DocParamSect>();
3617 }
3618 Token rv=ps->parse(cmdName,xmlContext,
3619 static_cast<DocParamSect::Direction>(direction));
3620 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3621 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3622}
DocParamSect::parse
Token parse(const DString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3522
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 4090 of file docnode.cpp.

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

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

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

3572{
3573 AUTO_TRACE();
3574 DocSimpleSect *ss=nullptr;
3575 bool needsSeparator = false;
3576 if (!children().empty() && // has previous element
3577 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3578 ss->type()==t && // of same type
3579 t!=DocSimpleSect::User) // but not user defined
3580 {
3581 // append to previous section
3582 needsSeparator = true;
3583 }
3584 else // start new section
3585 {
3586 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3587 ss = children().get_last<DocSimpleSect>();
3588 }
3589 Token rv = Token::make_RetVal_OK();
3590 if (xmlContext)
3591 {
3592 return ss->parseXml();
3593 }
3594 else
3595 {
3596 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3597 }
3598 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3599}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:3234
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:3288

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

4140{
4141 AUTO_TRACE();
4142 Token retval = parser()->tokenizer.lex();
4143 DString lang = parser()->context.token->name;
4144 if (!lang.empty() && lang.at(0)!='.')
4145 {
4146 lang="."+lang;
4147 }
4148 if (parser()->context.xmlComment)
4149 {
4150 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4151 }
4152 // search for the first non-whitespace line, index is stored in li
4153 size_t i=0,li=0,l=parser()->context.token->verb.length();
4154 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4155 {
4156 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4157 i++;
4158 }
4159 children().append<DocVerbatim>(parser(),thisVariant(),
4160 parser()->context.context,
4161 stripIndentation(parser()->context.token->verb.mid(li)),
4162 DocVerbatim::Code,
4163 parser()->context.isExample,
4164 parser()->context.exampleName,
4165 false,lang);
4166 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4167 {
4168 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4169 }
4170 parser()->tokenizer.setStatePara();
4171 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4172 return retval;
4173}
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:4683

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

3938{
3939 AUTO_TRACE();
3940 children().append<DocVhdlFlow>(parser(),thisVariant());
3941 children().get_last<DocVhdlFlow>()->parse();
3942}

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

3754{
3755 AUTO_TRACE();
3756 Token retval=parser()->tokenizer.lex();
3757 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3758 parser()->tokenizer.setStateXRefItem();
3759 retval=parser()->tokenizer.lex();
3760 if (retval.is(TokenRetval::RetVal_OK))
3761 {
3762 children().append<DocXRefItem>(parser(),thisVariant(),
3763 parser()->context.token->id,parser()->context.token->name);
3764 DocXRefItem *ref = children().get_last<DocXRefItem>();
3765 if (!ref->parse())
3766 {
3767 children().pop_back();
3768 }
3769 }
3770 parser()->tokenizer.setStatePara();
3771 return retval;
3772}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2076

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

4133{
4134 AUTO_TRACE();
4135 parser()->context.token->name = tokText;
4136 return parser()->defaultHandleToken(thisVariant(),tok,children());
4137}
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 5769 of file docnode.cpp.

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