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

3484 :
3485 DocCompoundNode(parser,parent),
3486 m_isFirst(false), m_isLast(false)
3487{
3488}
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 4135 of file docnode.cpp.

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

References DocNodeList::append(), DocSimpleSect::Attention, DocSimpleSect::Author, DocSimpleSect::Authors, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocCompoundNode::children(), CMD_ADDINDEX, CMD_AMP, CMD_ANCHOR, CMD_AT, CMD_ATTENTION, CMD_AUTHOR, CMD_AUTHORS, CMD_BOLD, CMD_BSLASH, CMD_CITE, CMD_CODE, CMD_COPYBRIEF, CMD_COPYDETAILS, CMD_COPYDOC, CMD_COPYRIGHT, CMD_DATE, CMD_DBONLY, CMD_DCOLON, CMD_DIAFILE, CMD_DOCBOOKINCLUDE, CMD_DOLLAR, CMD_DONTINCLUDE, CMD_DOT, CMD_DOTFILE, CMD_DOXYCONFIG, CMD_EMOJI, CMD_EMPHASIS, CMD_ENDCODE, CMD_ENDDBONLY, CMD_ENDDOT, CMD_ENDHTMLONLY, CMD_ENDICODE, CMD_ENDILITERAL, CMD_ENDINTERNAL, CMD_ENDIVERBATIM, CMD_ENDLATEXONLY, CMD_ENDLINK, CMD_ENDMANONLY, CMD_ENDMERMAID, CMD_ENDMSC, CMD_ENDPARBLOCK, CMD_ENDRTFONLY, CMD_ENDSECREFLIST, CMD_ENDUML, CMD_ENDVERBATIM, CMD_ENDXMLONLY, CMD_EQUAL, CMD_EXCEPTION, CMD_EXCLAMATION, CMD_FORMULA, CMD_GREATER, CMD_HASH, CMD_HTMLINCLUDE, CMD_HTMLONLY, CMD_IANCHOR, CMD_IFILE, CMD_ILINE, CMD_ILITERAL, CMD_IMAGE, CMD_IMPORTANT, CMD_INCLUDE, CMD_INCWITHLINES, CMD_INHERITDOC, CMD_INTERNAL, CMD_INTERNALREF, CMD_INVARIANT, CMD_IPREFIX, CMD_ISTARTCODE, CMD_IVERBATIM, CMD_JAVALINK, CMD_LATEXINCLUDE, CMD_LATEXONLY, CMD_LESS, CMD_LI, CMD_LINE, CMD_LINEBREAK, CMD_LINK, CMD_MANINCLUDE, CMD_MANONLY, CMD_MDASH, CMD_MERMAID, CMD_MERMAIDFILE, CMD_MINUS, CMD_MSC, CMD_MSCFILE, CMD_NDASH, CMD_NOTE, CMD_PAR, CMD_PARAGRAPH, CMD_PARAM, CMD_PARBLOCK, CMD_PERCENT, CMD_PIPE, CMD_PLANTUMLFILE, CMD_PLUS, CMD_POST, CMD_PRE, CMD_PUNT, CMD_QUESTION, CMD_QUOTE, CMD_REF, CMD_REMARK, CMD_RETURN, CMD_RETVAL, CMD_RTFINCLUDE, CMD_RTFONLY, CMD_SA, CMD_SECREFITEM, CMD_SECREFLIST, CMD_SECTION, CMD_SETSCOPE, CMD_SHOWDATE, CMD_SINCE, CMD_SKIP, CMD_SKIPLINE, CMD_SNIPPET, CMD_SNIPWITHLINES, CMD_STARTCODE, CMD_STARTUML, CMD_SUBPAGE, CMD_SUBPARAGRAPH, CMD_SUBSECTION, CMD_SUBSUBPARAGRAPH, CMD_SUBSUBSECTION, CMD_TPARAM, CMD_UNTIL, CMD_VERBATIM, CMD_VERBINCLUDE, CMD_VERSION, CMD_VHDLFLOW, CMD_WARNING, CMD_XMLINCLUDE, CMD_XMLONLY, CMD_XREFITEM, Mappers::cmdMapper, DocStyleChange::Code, Config_getBool, 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 3574 of file docnode.cpp.

3575{
3576 // get the argument of the cite command.
3577 Token tok=parser()->tokenizer.lex();
3578 if (!tok.is(TokenRetval::TK_WHITESPACE))
3579 {
3580 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3581 cmdChar,cmdName);
3582 return;
3583 }
3584 parser()->tokenizer.setStateDoxyConfig();
3585 tok=parser()->tokenizer.lex();
3586 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3587 {
3588 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3589 "argument of command '{:c}{}'",cmdChar,cmdName);
3590 return;
3591 }
3592 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3593 {
3594 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3595 tok.to_string(),cmdChar,cmdName);
3596 return;
3597 }
3598 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3599 if (opt)
3600 {
3601 DString optionValue;
3602 switch (opt->kind())
3603 {
3604 case ConfigOption::O_Bool:
3605 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3606 break;
3607 case ConfigOption::O_String:
3608 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3609 break;
3610 case ConfigOption::O_Enum:
3611 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3612 break;
3613 case ConfigOption::O_Int:
3614 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3615 break;
3616 case ConfigOption::O_List:
3617 {
3618 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3619 optionValue="";
3620 if (!lst->empty())
3621 {
3622 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3623 static const reg::Ex marker(R"(@(\d+))");
3624 reg::Iterator it(lstFormat,marker);
3625 reg::Iterator end;
3626 size_t index=0;
3627 // now replace all markers with the real text
3628 for ( ; it!=end ; ++it)
3629 {
3630 const auto &match = *it;
3631 size_t newIndex = match.position();
3632 size_t matchLen = match.length();
3633 optionValue += lstFormat.substr(index,newIndex-index);
3634 unsigned long entryIndex = std::stoul(match[1].str());
3635 if (entryIndex<(unsigned long)lst->size())
3636 {
3637 optionValue += lst->at(entryIndex);
3638 }
3639 index=newIndex+matchLen;
3640 }
3641 optionValue+=lstFormat.substr(index);
3642 }
3643 }
3644 break;
3645 case ConfigOption::O_Obsolete:
3646 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3647 cmdChar,cmdName,parser()->context.token->name);
3648 break;
3649 case ConfigOption::O_Disabled:
3650 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3651 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3652 cmdChar,cmdName,parser()->context.token->name);
3653 break;
3654 case ConfigOption::O_Info:
3655 // nothing to show here
3656 break;
3657 }
3658 if (!optionValue.empty())
3659 {
3660 children().append<DocWord>(parser(),thisVariant(),optionValue);
3661 }
3662 }
3663 else
3664 {
3665 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3666 cmdChar,cmdName,parser()->context.token->name);
3667 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3668 }
3669 parser()->tokenizer.setStatePara();
3670}
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:227
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:176
theTranslator
Translator * theTranslator
Definition language.cpp:71
reg::match
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:858

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

3544{
3545 AUTO_TRACE();
3546 // get the argument of the emoji command.
3547 Token tok=parser()->tokenizer.lex();
3548 if (!tok.is(TokenRetval::TK_WHITESPACE))
3549 {
3550 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3551 cmdChar,cmdName);
3552 return;
3553 }
3554 parser()->tokenizer.setStateEmoji();
3555 tok=parser()->tokenizer.lex();
3556 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3557 {
3558 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3559 "argument of command '{:c}{}'",cmdChar,cmdName);
3560 parser()->tokenizer.setStatePara();
3561 return;
3562 }
3563 else if (!tok.is(TokenRetval::TK_WORD))
3564 {
3565 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3566 tok.to_string(),cmdChar,cmdName);
3567 parser()->tokenizer.setStatePara();
3568 return;
3569 }
3570 children().append<DocEmoji>(parser(),thisVariant(),parser()->context.token->name);
3571 parser()->tokenizer.setStatePara();
3572}
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 3824 of file docnode.cpp.

3825{
3826 AUTO_TRACE("cmdName={}",cmdName);
3827 DString saveCmdName = cmdName;
3828 Token tok=parser()->tokenizer.lex();
3829 if (!tok.is(TokenRetval::TK_WHITESPACE))
3830 {
3831 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3832 saveCmdName);
3833 return;
3834 }
3835 parser()->tokenizer.setStateFile();
3836 tok=parser()->tokenizer.lex();
3837 parser()->tokenizer.setStatePara();
3838 if (!tok.is(TokenRetval::TK_WORD))
3839 {
3840 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3841 tok.to_string(),saveCmdName);
3842 return;
3843 }
3844 DString name = parser()->context.token->name;
3845 children().append<T>(parser(),thisVariant(),name,
3846 parser()->context.context,
3847 parser()->context.fileName,
3848 parser()->tokenizer.getLineNr());
3849 auto df = children().get_last<T>();
3850 if (!df->parse())
3851 {
3852 children().pop_back();
3853 }
3854}
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 5415 of file docnode.cpp.

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

4041{
4042 AUTO_TRACE();
4043 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
4044 Token retval = children().get_last<DocHtmlHeader>()->parse();
4045 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
4046}

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

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

3905{
3906 AUTO_TRACE("cmdName={}",cmdName);
3907 DString saveCmdName = cmdName;
3908 Token tok=parser()->tokenizer.lex();
3909 bool isBlock = false;
3910 bool trimLeft = false;
3911 bool localScope = false;
3912 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3913 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3914 {
3915 parser()->tokenizer.setStateOptions();
3916 parser()->tokenizer.lex();
3917 parser()->tokenizer.setStatePara();
3918 StringVector optList=split(parser()->context.token->name.str(),",");
3919 auto contains = [&optList](const char *kw)
3920 {
3921 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
3922 };
3923 localScope = contains("local");
3924 if (contains("nostrip"))
3925 {
3926 stripCodeComments = false;
3927 }
3928 else if (contains("strip"))
3929 {
3930 stripCodeComments = true;
3931 }
3932 if (t==DocInclude::Snippet && contains("trimleft"))
3933 {
3934 trimLeft = true;
3935 }
3936
3937 if (contains("lineno"))
3938 {
3939 if (t==DocInclude::Include) t = DocInclude::IncWithLines;
3940 else if (t==DocInclude::Snippet) t = DocInclude::SnippetWithLines;
3941 else if (t==DocInclude::DontInclude) t = DocInclude::DontIncWithLines;
3942 }
3943 tok=parser()->tokenizer.lex();
3944 if (!tok.is(TokenRetval::TK_WHITESPACE))
3945 {
3946 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3947 saveCmdName);
3948 return;
3949 }
3950 }
3951 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
3952 {
3953 parser()->tokenizer.setStateBlock();
3954 parser()->tokenizer.lex();
3955 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
3956 parser()->tokenizer.setStatePara();
3957 parser()->tokenizer.lex();
3958 }
3959 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3960 {
3961 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3962 saveCmdName);
3963 return;
3964 }
3965 parser()->tokenizer.setStateFile();
3966 tok=parser()->tokenizer.lex();
3967 parser()->tokenizer.setStatePara();
3968 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3969 {
3970 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3971 "argument of command {}",saveCmdName);
3972 return;
3973 }
3974 else if (!tok.is(TokenRetval::TK_WORD))
3975 {
3976 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3977 tok.to_string(),saveCmdName);
3978 return;
3979 }
3980 DString fileName = parser()->context.token->name;
3981 DString blockId;
3982 if (t==DocInclude::Snippet || t==DocInclude::SnippetWithLines)
3983 {
3984 if (fileName == "this") fileName=parser()->context.fileName;
3985 parser()->tokenizer.setStateSnippet();
3986 tok=parser()->tokenizer.lex();
3987 parser()->tokenizer.setStatePara();
3988 if (!tok.is(TokenRetval::TK_WORD))
3989 {
3990 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
3991 tok.to_string(),saveCmdName);
3992 return;
3993 }
3994 blockId = "["+parser()->context.token->name+"]";
3995 }
3996
3997 children().append<DocInclude>(parser(),
3998 thisVariant(),
3999 fileName,
4000 localScope ? parser()->context.context : "",
4001 t,
4002 stripCodeComments,
4003 parser()->context.isExample,
4004 parser()->context.exampleName,
4005 blockId,isBlock,trimLeft);
4006 children().get_last<DocInclude>()->parse();
4007}
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 3764 of file docnode.cpp.

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

4095{
4096 if (parser()->context.memberDef) // inheriting docs from a member
4097 {
4098 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4099 if (reMd) // member from which was inherited.
4100 {
4101 const MemberDef *thisMd = parser()->context.memberDef;
4102 bool hasParamCommand = false;
4103 bool hasReturnCommand = false;
4104 StringMultiSet retvalsFound;
4105 StringMultiSet paramsFound;
4106 { DocParser::AutoSaveContext saveContext(*parser());
4107 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4108 parser()->context.scope=reMd->getOuterScope();
4109 if (parser()->context.scope!=Doxygen::globalScope)
4110 {
4111 parser()->context.context=parser()->context.scope->name();
4112 }
4113 parser()->context.memberDef=reMd;
4114 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4115 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4116 parser()->context.copyStack.push_back(reMd);
4117 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4118 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4119 parser()->context.copyStack.pop_back();
4120 hasParamCommand = parser()->context.hasParamCommand;
4121 hasReturnCommand = parser()->context.hasReturnCommand;
4122 retvalsFound = parser()->context.retvalsFound;
4123 paramsFound = parser()->context.paramsFound;
4124 }
4125 parser()->context.hasParamCommand = hasParamCommand;
4126 parser()->context.hasReturnCommand = hasReturnCommand;
4127 parser()->context.retvalsFound = retvalsFound;
4128 parser()->context.paramsFound = paramsFound;
4129 parser()->context.memberDef = thisMd;
4130 }
4131 }
4132}
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:1881
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 3863 of file docnode.cpp.

3864{
3865 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3866 DString saveCmdName = cmdName;
3867 Token tok=parser()->tokenizer.lex();
3868 if (!tok.is(TokenRetval::TK_WHITESPACE))
3869 {
3870 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3871 saveCmdName);
3872 return;
3873 }
3874 parser()->tokenizer.setStateLink();
3875 tok=parser()->tokenizer.lex();
3876 if (!tok.is(TokenRetval::TK_WORD))
3877 {
3878 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3879 tok.to_string(),saveCmdName);
3880 return;
3881 }
3882 if (saveCmdName == "javalink")
3883 {
3884 children().append<DocStyleChange>(parser(),thisVariant(),
3885 parser()->context.nodeStack.size(),
3886 DocStyleChange::Code,cmdName,true);
3887 }
3888 parser()->tokenizer.setStatePara();
3889 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3890 DocLink *lnk = children().get_last<DocLink>();
3891 if (saveCmdName == "javalink")
3892 {
3893 children().append<DocStyleChange>(parser(),thisVariant(),
3894 parser()->context.nodeStack.size(),
3895 DocStyleChange::Code,cmdName,false);
3896 }
3897 DString leftOver = lnk->parse(isJavaLink);
3898 if (!leftOver.empty())
3899 {
3900 children().append<DocWord>(parser(),thisVariant(),leftOver);
3901 }
3902}
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 3520 of file docnode.cpp.

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

4010{
4011 AUTO_TRACE("cmdName={}",cmdName);
4012 DString saveCmdName = cmdName;
4013 // get the argument of the section command.
4014 Token tok=parser()->tokenizer.lex();
4015 if (!tok.is(TokenRetval::TK_WHITESPACE))
4016 {
4017 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4018 cmdChar,saveCmdName);
4019 return;
4020 }
4021 tok=parser()->tokenizer.lex();
4022 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4023 {
4024 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4025 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4026 return;
4027 }
4028 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4029 {
4030 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4031 tok.to_string(),cmdChar,saveCmdName);
4032 return;
4033 }
4034 parser()->context.token->sectionId = parser()->context.token->name;
4035 parser()->tokenizer.setStateSkipTitle();
4036 parser()->tokenizer.lex();
4037 parser()->tokenizer.setStatePara();
4038}
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 3694 of file docnode.cpp.

3695{
3696 AUTO_TRACE();
3697 DString fmt;
3698 DString date;
3699 Token tok=parser()->tokenizer.lex();
3700 if (!tok.is(TokenRetval::TK_WHITESPACE))
3701 {
3702 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3703 cmdChar,cmdName);
3704 return;
3705 }
3706 parser()->tokenizer.setStateQuotedString();
3707 tok = parser()->tokenizer.lex();
3708 if (!tok.is(TokenRetval::TK_WORD))
3709 {
3710 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3711 cmdChar,cmdName);
3712 parser()->tokenizer.setStatePara();
3713 return;
3714 }
3715 fmt = parser()->context.token->name;
3716
3717 parser()->tokenizer.setStateShowDate();
3718 tok = parser()->tokenizer.lex();
3719
3720 DString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : DString();
3721 DString specDate = specDateRaw.stripWhiteSpace();
3722 bool specDateOnlyWS = !specDateRaw.empty() && specDate.empty();
3723 if (!specDate.empty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3724 {
3725 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3726 cmdChar,cmdName);
3727 parser()->tokenizer.setStatePara();
3728 return;
3729 }
3730
3731 std::tm dat{};
3732 int specFormat=0;
3733 DString err = dateTimeFromString(specDate,dat,specFormat);
3734 if (!err.empty())
3735 {
3736 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3737 cmdChar,cmdName,err);
3738 parser()->tokenizer.setStatePara();
3739 return;
3740 }
3741
3742 int usedFormat=0;
3743 DString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3744
3745 // warn the user if the format contains markers that are not explicitly filled in
3746 for (int i=0;i<SF_NumBits;i++)
3747 {
3748 int bitMask = 1<<i;
3749 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3750 {
3751 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.",
3752 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3753 }
3754 }
3755
3756 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3757 if (specDateOnlyWS) // specDate is only whitespace
3758 {
3759 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3760 }
3761 parser()->tokenizer.setStatePara();
3762}
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:174
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:133
SF_bit2str
constexpr const char * SF_bit2str(int bitNumber)
Helper function that returns the name related one of the SF bits.
Definition datetime.h:32
SF_NumBits
constexpr int SF_NumBits
number of bits in SF vector
Definition datetime.h:27
err
#define err(fmt,...)
Definition message.h:127

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

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

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

4059{
4060 AUTO_TRACE();
4061 Token retval = parser()->tokenizer.lex();
4062 DString lang = parser()->context.token->name;
4063 if (!lang.empty() && lang.at(0)!='.')
4064 {
4065 lang="."+lang;
4066 }
4067 if (parser()->context.xmlComment)
4068 {
4069 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
4070 }
4071 // search for the first non-whitespace line, index is stored in li
4072 size_t i=0,li=0,l=parser()->context.token->verb.length();
4073 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
4074 {
4075 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
4076 i++;
4077 }
4078 children().append<DocVerbatim>(parser(),thisVariant(),
4079 parser()->context.context,
4080 stripIndentation(parser()->context.token->verb.mid(li)),
4081 DocVerbatim::Code,
4082 parser()->context.isExample,
4083 parser()->context.exampleName,
4084 false,lang);
4085 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4086 {
4087 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
4088 }
4089 parser()->tokenizer.setStatePara();
4090 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4091 return retval;
4092}
DString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition dstring.h:690
DString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition dstring.h:155
substitute
DString substitute(const DString &s, const DString &src, const DString &dst)
substitute all occurrences of src in s by dst
Definition dstring.cpp:481
stripIndentation
DString stripIndentation(const DString &s, bool skipFirstLine)
Definition util.cpp:4685

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

3857{
3858 AUTO_TRACE();
3859 children().append<DocVhdlFlow>(parser(),thisVariant());
3860 children().get_last<DocVhdlFlow>()->parse();
3861}

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

3673{
3674 AUTO_TRACE();
3675 Token retval=parser()->tokenizer.lex();
3676 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3677 parser()->tokenizer.setStateXRefItem();
3678 retval=parser()->tokenizer.lex();
3679 if (retval.is(TokenRetval::RetVal_OK))
3680 {
3681 children().append<DocXRefItem>(parser(),thisVariant(),
3682 parser()->context.token->id,parser()->context.token->name);
3683 DocXRefItem *ref = children().get_last<DocXRefItem>();
3684 if (!ref->parse())
3685 {
3686 children().pop_back();
3687 }
3688 }
3689 parser()->tokenizer.setStatePara();
3690 return retval;
3691}
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 4051 of file docnode.cpp.

4052{
4053 AUTO_TRACE();
4054 parser()->context.token->name = tokText;
4055 return parser()->defaultHandleToken(thisVariant(),tok,children());
4056}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token &tok, DocNodeList &children, bool handleWord=true)
Definition docparser.cpp:1476

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

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