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

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

#include <src/docnode.h>

Inheritance diagram for DocPara:
Collaboration diagram for DocPara:

Public Member Functions

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

Private Attributes

bool m_isFirst = false
bool m_isLast = false
HtmlAttribList m_attribs

Additional Inherited Members

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

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1088 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3480 of file docnode.cpp.

3480 :
3481 DocCompoundNode(parser,parent),
3482 m_isFirst(FALSE), m_isLast(FALSE)
3483{
3484}
DocCompoundNode::DocCompoundNode
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:141
DocNode::parser
DocParser * parser()
Definition docnode.h:98
DocNode::parent
DocNodeVariant * parent()
Definition docnode.h:90
DocPara::m_isFirst
bool m_isFirst
Definition docnode.h:1123
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1124
FALSE
#define FALSE
Definition qcstring.h:34

References DocCompoundNode::DocCompoundNode(), FALSE, m_isFirst, m_isLast, DocNode::parent(), and DocNode::parser().

Referenced by parse().

Member Function Documentation

◆ attribs()

const HtmlAttribList & DocPara::attribs ( ) const
inline

Definition at line 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().

◆ handleCommand()

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

Definition at line 4131 of file docnode.cpp.

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

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

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3570 of file docnode.cpp.

3571{
3572 // get the argument of the cite command.
3573 Token tok=parser()->tokenizer.lex();
3574 if (!tok.is(TokenRetval::TK_WHITESPACE))
3575 {
3576 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3577 cmdChar,cmdName);
3578 return;
3579 }
3580 parser()->tokenizer.setStateDoxyConfig();
3581 tok=parser()->tokenizer.lex();
3582 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3583 {
3584 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3585 "argument of command '{:c}{}'",cmdChar,cmdName);
3586 return;
3587 }
3588 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3589 {
3590 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3591 tok.to_string(),cmdChar,cmdName);
3592 return;
3593 }
3594 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3595 if (opt)
3596 {
3597 QCString optionValue;
3598 switch (opt->kind())
3599 {
3600 case ConfigOption::O_Bool:
3601 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3602 break;
3603 case ConfigOption::O_String:
3604 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3605 break;
3606 case ConfigOption::O_Enum:
3607 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3608 break;
3609 case ConfigOption::O_Int:
3610 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3611 break;
3612 case ConfigOption::O_List:
3613 {
3614 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3615 optionValue="";
3616 if (!lst->empty())
3617 {
3618 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3619 static const reg::Ex marker(R"(@(\d+))");
3620 reg::Iterator it(lstFormat,marker);
3621 reg::Iterator end;
3622 size_t index=0;
3623 // now replace all markers with the real text
3624 for ( ; it!=end ; ++it)
3625 {
3626 const auto &match = *it;
3627 size_t newIndex = match.position();
3628 size_t matchLen = match.length();
3629 optionValue += lstFormat.substr(index,newIndex-index);
3630 unsigned long entryIndex = std::stoul(match[1].str());
3631 if (entryIndex<(unsigned long)lst->size())
3632 {
3633 optionValue += lst->at(entryIndex);
3634 }
3635 index=newIndex+matchLen;
3636 }
3637 optionValue+=lstFormat.substr(index);
3638 }
3639 }
3640 break;
3641 case ConfigOption::O_Obsolete:
3642 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3643 cmdChar,cmdName,parser()->context.token->name);
3644 break;
3645 case ConfigOption::O_Disabled:
3646 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3647 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3648 cmdChar,cmdName,parser()->context.token->name);
3649 break;
3650 case ConfigOption::O_Info:
3651 // nothing to show here
3652 break;
3653 }
3654 if (!optionValue.isEmpty())
3655 {
3656 children().append<DocWord>(parser(),thisVariant(),optionValue);
3657 }
3658 }
3659 else
3660 {
3661 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3662 cmdChar,cmdName,parser()->context.token->name);
3663 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3664 }
3665 parser()->tokenizer.setStatePara();
3666}
ConfigImpl::instance
static ConfigImpl * instance()
Definition configimpl.h:351
ConfigImpl::get
ConfigOption * get(const QCString &name) const
Definition configimpl.h:400
ConfigOption::O_Disabled
@ O_Disabled
Disabled compile time option.
Definition configimpl.h:55
ConfigOption::O_List
@ O_List
A list of items.
Definition configimpl.h:49
ConfigOption::O_Enum
@ O_Enum
A fixed set of items.
Definition configimpl.h:50
ConfigOption::O_Bool
@ O_Bool
A boolean value.
Definition configimpl.h:53
ConfigOption::O_String
@ O_String
A single item.
Definition configimpl.h:51
ConfigOption::O_Obsolete
@ O_Obsolete
An obsolete option.
Definition configimpl.h:54
ConfigOption::O_Int
@ O_Int
An integer value.
Definition configimpl.h:52
ConfigOption::O_Info
@ O_Info
A section header.
Definition configimpl.h:48
ConfigOption::kind
OptionType kind() const
Definition configimpl.h:70
DocTokenizer::setStateDoxyConfig
void setStateDoxyConfig()
Definition doctokenizer.l:2111
Token::is
bool is(TokenRetval rv) const
Definition doctokenizer.h:122
Token::to_string
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
Definition doctokenizer.h:93
Token::is_any_of
bool is_any_of(ARGS... args) const
Definition doctokenizer.h:117
Translator::trWriteList
virtual QCString trWriteList(int numEntries)=0
end
DirIterator end(const DirIterator &) noexcept
Definition dir.cpp:175
theTranslator
Translator * theTranslator
Definition language.cpp:71
reg::match
bool match(std::string_view str, Match &match, const Ex &re)
Matches a given string str for a match against regular expression re.
Definition regex.cpp:855

References DocNodeList::append(), DocCompoundNode::children(), DocParser::context, end(), ConfigImpl::get(), ConfigImpl::instance(), Token::is(), Token::is_any_of(), QCString::isEmpty(), ConfigOption::kind(), DocTokenizer::lex(), TokenInfo::name, ConfigOption::O_Bool, ConfigOption::O_Disabled, ConfigOption::O_Enum, ConfigOption::O_Info, ConfigOption::O_Int, ConfigOption::O_List, ConfigOption::O_Obsolete, ConfigOption::O_String, DocNode::parser(), DocTokenizer::setStateDoxyConfig(), DocTokenizer::setStatePara(), theTranslator, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, ConfigEnum::valueRef(), ConfigString::valueRef(), ConfigBool::valueStringRef(), ConfigInt::valueStringRef(), warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleEmoji()

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

Definition at line 3539 of file docnode.cpp.

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

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

Referenced by handleCommand().

◆ handleFile()

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

Definition at line 3820 of file docnode.cpp.

3821{
3822 AUTO_TRACE("cmdName={}",cmdName);
3823 QCString saveCmdName = cmdName;
3824 Token tok=parser()->tokenizer.lex();
3825 if (!tok.is(TokenRetval::TK_WHITESPACE))
3826 {
3827 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3828 saveCmdName);
3829 return;
3830 }
3831 parser()->tokenizer.setStateFile();
3832 tok=parser()->tokenizer.lex();
3833 parser()->tokenizer.setStatePara();
3834 if (!tok.is(TokenRetval::TK_WORD))
3835 {
3836 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3837 tok.to_string(),saveCmdName);
3838 return;
3839 }
3840 QCString name = parser()->context.token->name;
3841 children().append<T>(parser(),thisVariant(),name,
3842 parser()->context.context,
3843 parser()->context.fileName,
3844 parser()->tokenizer.getLineNr());
3845 auto df = children().get_last<T>();
3846 if (!df->parse())
3847 {
3848 children().pop_back();
3849 }
3850}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2075
DocTokenizer::getLineNr
int getLineNr() const
Definition doctokenizer.l:2284
DocParserContext::fileName
QCString fileName
Definition docparser_p.h:71

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

Referenced by handleCommand().

◆ handleHtmlEndTag()

Token DocPara::handleHtmlEndTag ( const QCString & tagName)

Definition at line 5411 of file docnode.cpp.

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

References DocNodeList::append(), ASSERT, AUTO_TRACE, AUTO_TRACE_EXIT, DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, DocStyleChange::Del, DocStyleChange::Div, FALSE, DocParser::handleStyleLeave(), HTML_A, HTML_BLOCKQUOTE, HTML_BOLD, HTML_BR, HTML_CAPTION, HTML_CENTER, HTML_CITE, HTML_CODE, HTML_DD, HTML_DEL, HTML_DETAILS, HTML_DIV, HTML_DL, HTML_DT, HTML_EMPHASIS, HTML_H1, HTML_H2, HTML_H3, HTML_H4, HTML_H5, HTML_H6, HTML_HR, HTML_IMG, HTML_INS, HTML_KBD, HTML_LI, HTML_OL, HTML_P, HTML_PRE, HTML_S, HTML_SMALL, HTML_SPAN, HTML_STRIKE, HTML_SUB, HTML_SUP, HTML_TABLE, HTML_TBODY, HTML_TD, HTML_TFOOT, HTML_TH, HTML_THEAD, HTML_TR, HTML_TT, HTML_UL, HTML_UNDERLINE, Mappers::htmlTagMapper, DocStyleChange::Ins, insideBlockQuote(), insideDetails(), insideLI(), insideOL(), insideUL(), DocStyleChange::Italic, DocStyleChange::Kbd, DocNode::parser(), DocStyleChange::Preformatted, DocStyleChange::S, DocTokenizer::setInsidePre(), DocNode::setInsidePreformatted(), DocStyleChange::Small, DocStyleChange::Span, DocStyleChange::Strike, DocStyleChange::Subscript, DocStyleChange::Superscript, DocNode::thisVariant(), Token::to_string(), DocParser::tokenizer, DocStyleChange::Typewriter, DocStyleChange::Underline, UNKNOWN, warn_doc_error, XML_C, XML_DESCRIPTION, XML_EXAMPLE, XML_EXCEPTION, XML_INCLUDE, XML_INHERITDOC, XML_ITEM, XML_LIST, XML_LISTHEADER, XML_PARA, XML_PARAM, XML_PARAMREF, XML_PERMISSION, XML_REMARKS, XML_RETURNS, XML_SEE, XML_SEEALSO, XML_SUMMARY, XML_TERM, XML_TYPEPARAM, XML_TYPEPARAMREF, and XML_VALUE.

Referenced by parse().

◆ handleHtmlHeader()

Token DocPara::handleHtmlHeader ( const HtmlAttribList & tagHtmlAttribs,
int level )

Definition at line 4036 of file docnode.cpp.

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

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

Referenced by handleHtmlStartTag().

◆ handleHtmlStartTag()

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

Definition at line 4941 of file docnode.cpp.

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

References DocNodeList::append(), ASSERT, TokenInfo::attribsStr, AUTO_TRACE, AUTO_TRACE_EXIT, GrowVector< T >::back(), DocStyleChange::Bold, DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Cite, DocStyleChange::Code, Config_getBool, DocParser::context, DocStyleChange::Del, DocStyleChange::Div, DocParamSect::Exception, FALSE, findAttribute(), DocNodeList::get_last(), DocParser::handleAHref(), handleHtmlHeader(), DocParser::handleImg(), handleInheritDoc(), DocParser::handleLinkedWord(), handleParamSection(), handleSimpleSection(), handleStartCode(), DocParser::handleStyleEnter(), DocParser::handleStyleLeave(), DocParserContext::hasReturnCommand, HTML_A, HTML_BLOCKQUOTE, HTML_BOLD, HTML_BR, HTML_CAPTION, HTML_CENTER, HTML_CITE, HTML_CODE, HTML_DD, HTML_DEL, HTML_DETAILS, HTML_DIV, HTML_DL, HTML_DT, HTML_EMPHASIS, HTML_H1, HTML_H2, HTML_H3, HTML_H4, HTML_H5, HTML_H6, HTML_HR, HTML_IMG, HTML_INS, HTML_KBD, HTML_LI, HTML_OL, HTML_P, HTML_PRE, HTML_S, HTML_SMALL, HTML_SPAN, HTML_STRIKE, HTML_SUB, HTML_SUP, HTML_TABLE, HTML_TBODY, HTML_TD, HTML_TFOOT, HTML_TH, HTML_THEAD, HTML_TR, HTML_TT, HTML_UL, HTML_UNDERLINE, Mappers::htmlTagMapper, DocStyleChange::Ins, DocParserContext::inSeeBlock, insideDetails(), insideDL(), insideOL(), insideTable(), insideUL(), Token::is(), QCString::isEmpty(), DocStyleChange::Italic, DocStyleChange::Kbd, TokenInfo::name, DocParserContext::nodeStack, DocHtmlList::Ordered, DocParamSect::Param, DocNode::parent(), parse(), DocNode::parser(), DocHtmlDetails::parseSummary(), GrowVector< T >::pop_back(), DocStyleChange::Preformatted, DocSimpleSect::Return, DocStyleChange::S, DocSimpleSect::See, DocTokenizer::setInsidePre(), DocNode::setInsidePreformatted(), DocTokenizer::setStatePara(), DocTokenizer::setStateXmlCode(), DocStyleChange::Small, DocStyleChange::Span, DocStyleChange::Strike, DocStyleChange::Subscript, DocHtmlDetails::summary(), DocStyleChange::Superscript, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TRUE, DocSimpleSect::type(), DocStyleChange::Typewriter, DocStyleChange::Underline, unescapeCRef(), UNKNOWN, DocHtmlList::Unordered, warn_doc_error, XML_C, XML_CmdMask, XML_DESCRIPTION, XML_EXAMPLE, XML_EXCEPTION, XML_INCLUDE, XML_INHERITDOC, XML_ITEM, XML_LIST, XML_LISTHEADER, XML_PARA, XML_PARAM, XML_PARAMREF, XML_PERMISSION, XML_REMARKS, XML_RETURNS, XML_SEE, XML_SEEALSO, XML_SUMMARY, XML_TERM, XML_TYPEPARAM, XML_TYPEPARAMREF, XML_VALUE, and DocParserContext::xmlComment.

Referenced by parse().

◆ handleInclude()

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

Definition at line 3900 of file docnode.cpp.

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

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

Referenced by handleCommand().

◆ handleIncludeOperator()

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

Definition at line 3760 of file docnode.cpp.

3761{
3762 AUTO_TRACE("cmdName={}",cmdName);
3763 QCString saveCmdName = cmdName;
3764 Token tok=parser()->tokenizer.lex();
3765 if (!tok.is(TokenRetval::TK_WHITESPACE))
3766 {
3767 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3768 saveCmdName);
3769 return;
3770 }
3771 parser()->tokenizer.setStatePattern();
3772 tok=parser()->tokenizer.lex();
3773 parser()->tokenizer.setStatePara();
3774 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3775 {
3776 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3777 "argument of command {}", saveCmdName);
3778 return;
3779 }
3780 else if (!tok.is(TokenRetval::TK_WORD))
3781 {
3782 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3783 tok.to_string(),saveCmdName);
3784 return;
3785 }
3786 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3787 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3788 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3789 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3790 //TODO get from context the stripCodeComments()
3791 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3792 children().append<DocIncOperator>(parser(),thisVariant(),t,
3793 parser()->context.token->name,
3794 parser()->context.context,
3795 stripCodeComments,
3796 parser()->context.isExample,
3797 parser()->context.exampleName
3798 );
3799 DocIncOperator *op = children().get_last<DocIncOperator>();
3800 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3801 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3802 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3803 bool isFirst = !n1 || // no last node
3804 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3805 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3806 op->markFirst(isFirst);
3807 op->markLast(true);
3808 if (n1_docIncOp)
3809 {
3810 n1_docIncOp->markLast(false);
3811 }
3812 else if (n1_docWs && n2_docIncOp)
3813 {
3814 n2_docIncOp->markLast(false);
3815 }
3816 op->parse();
3817}
DocIncOperator::markLast
void markLast(bool v=TRUE)
Definition docnode.h:505
DocPara::isFirst
bool isFirst() const
Definition docnode.h:1096
DocTokenizer::setStatePattern
void setStatePattern()
Definition doctokenizer.l:2089
GrowVector::size
size_t size() const
returns the number of elements
Definition growvector.h:93
GrowVector::end
iterator end()
returns an iterator to the end
Definition growvector.h:88

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

Referenced by handleCommand().

◆ handleInheritDoc()

void DocPara::handleInheritDoc ( )

Definition at line 4090 of file docnode.cpp.

4091{
4092 if (parser()->context.memberDef) // inheriting docs from a member
4093 {
4094 const MemberDef *reMd = parser()->context.memberDef->reimplements();
4095 if (reMd) // member from which was inherited.
4096 {
4097 const MemberDef *thisMd = parser()->context.memberDef;
4098 bool hasParamCommand = false;
4099 bool hasReturnCommand = false;
4100 StringMultiSet retvalsFound;
4101 StringMultiSet paramsFound;
4102 { DocParser::AutoSaveContext saveContext(*parser());
4103 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
4104 parser()->context.scope=reMd->getOuterScope();
4105 if (parser()->context.scope!=Doxygen::globalScope)
4106 {
4107 parser()->context.context=parser()->context.scope->name();
4108 }
4109 parser()->context.memberDef=reMd;
4110 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
4111 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
4112 parser()->context.copyStack.push_back(reMd);
4113 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
4114 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
4115 parser()->context.copyStack.pop_back();
4116 hasParamCommand = parser()->context.hasParamCommand;
4117 hasReturnCommand = parser()->context.hasReturnCommand;
4118 retvalsFound = parser()->context.retvalsFound;
4119 paramsFound = parser()->context.paramsFound;
4120 }
4121 parser()->context.hasParamCommand = hasParamCommand;
4122 parser()->context.hasReturnCommand = hasReturnCommand;
4123 parser()->context.retvalsFound = retvalsFound;
4124 parser()->context.paramsFound = paramsFound;
4125 parser()->context.memberDef = thisMd;
4126 }
4127 }
4128}
Definition::briefDescription
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
Definition::documentation
virtual QCString documentation() const =0
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
Definition::name
virtual const QCString & name() const =0
DocParser::internalValidatingParseDoc
Token internalValidatingParseDoc(DocNodeVariant *parent, DocNodeList &children, const QCString &doc)
Definition docparser.cpp:1860
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:76
DocParserContext::styleStack
DocStyleChangeStack styleStack
Definition docparser_p.h:68
DocParserContext::paramsFound
StringMultiSet paramsFound
Definition docparser_p.h:77
DocParserContext::copyStack
DefinitionStack copyStack
Definition docparser_p.h:70

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleLink()

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

Definition at line 3859 of file docnode.cpp.

3860{
3861 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3862 QCString saveCmdName = cmdName;
3863 Token tok=parser()->tokenizer.lex();
3864 if (!tok.is(TokenRetval::TK_WHITESPACE))
3865 {
3866 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3867 saveCmdName);
3868 return;
3869 }
3870 parser()->tokenizer.setStateLink();
3871 tok=parser()->tokenizer.lex();
3872 if (!tok.is(TokenRetval::TK_WORD))
3873 {
3874 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3875 tok.to_string(),saveCmdName);
3876 return;
3877 }
3878 if (saveCmdName == "javalink")
3879 {
3880 children().append<DocStyleChange>(parser(),thisVariant(),
3881 parser()->context.nodeStack.size(),
3882 DocStyleChange::Code,cmdName,TRUE);
3883 }
3884 parser()->tokenizer.setStatePara();
3885 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3886 DocLink *lnk = children().get_last<DocLink>();
3887 if (saveCmdName == "javalink")
3888 {
3889 children().append<DocStyleChange>(parser(),thisVariant(),
3890 parser()->context.nodeStack.size(),
3891 DocStyleChange::Code,cmdName,FALSE);
3892 }
3893 QCString leftOver = lnk->parse(isJavaLink);
3894 if (!leftOver.isEmpty())
3895 {
3896 children().append<DocWord>(parser(),thisVariant(),leftOver);
3897 }
3898}
DocTokenizer::setStateLink
void setStateLink()
Definition doctokenizer.l:2097

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

Referenced by handleCommand().

◆ handleParamSection()

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

Definition at line 3516 of file docnode.cpp.

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

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleSection()

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

Definition at line 4005 of file docnode.cpp.

4006{
4007 AUTO_TRACE("cmdName={}",cmdName);
4008 QCString saveCmdName = cmdName;
4009 // get the argument of the section command.
4010 Token tok=parser()->tokenizer.lex();
4011 if (!tok.is(TokenRetval::TK_WHITESPACE))
4012 {
4013 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
4014 cmdChar,saveCmdName);
4015 return;
4016 }
4017 tok=parser()->tokenizer.lex();
4018 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4019 {
4020 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
4021 "argument of command '{:c}{}'", cmdChar,saveCmdName);
4022 return;
4023 }
4024 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
4025 {
4026 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
4027 tok.to_string(),cmdChar,saveCmdName);
4028 return;
4029 }
4030 parser()->context.token->sectionId = parser()->context.token->name;
4031 parser()->tokenizer.setStateSkipTitle();
4032 parser()->tokenizer.lex();
4033 parser()->tokenizer.setStatePara();
4034}
DocTokenizer::setStateSkipTitle
void setStateSkipTitle()
Definition doctokenizer.l:2140

References AUTO_TRACE, DocParser::context, Token::is(), Token::is_any_of(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), TokenInfo::sectionId, DocTokenizer::setStatePara(), DocTokenizer::setStateSkipTitle(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleShowDate()

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

Definition at line 3690 of file docnode.cpp.

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

References DocNodeList::append(), AUTO_TRACE, DocCompoundNode::children(), DocParser::context, dateTimeFromString(), err, formatDateTime(), Token::is(), Token::is_any_of(), QCString::isEmpty(), DocTokenizer::lex(), TokenInfo::name, DocNode::parser(), DocTokenizer::setStatePara(), DocTokenizer::setStateQuotedString(), DocTokenizer::setStateShowDate(), SF_bit2str(), SF_NumBits, QCString::stripWhiteSpace(), DocNode::thisVariant(), DocParserContext::token, DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleSimpleSection()

Token DocPara::handleSimpleSection ( DocSimpleSect::Type t,
bool xmlContext = FALSE )

Definition at line 3486 of file docnode.cpp.

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

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 4054 of file docnode.cpp.

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

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleVhdlFlow()

void DocPara::handleVhdlFlow ( )

Definition at line 3852 of file docnode.cpp.

3853{
3854 AUTO_TRACE();
3855 children().append<DocVhdlFlow>(parser(),thisVariant());
3856 children().get_last<DocVhdlFlow>()->parse();
3857}

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

3669{
3670 AUTO_TRACE();
3671 Token retval=parser()->tokenizer.lex();
3672 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3673 parser()->tokenizer.setStateXRefItem();
3674 retval=parser()->tokenizer.lex();
3675 if (retval.is(TokenRetval::RetVal_OK))
3676 {
3677 children().append<DocXRefItem>(parser(),thisVariant(),
3678 parser()->context.token->id,parser()->context.token->name);
3679 DocXRefItem *ref = children().get_last<DocXRefItem>();
3680 if (!ref->parse())
3681 {
3682 children().pop_back();
3683 }
3684 }
3685 parser()->tokenizer.setStatePara();
3686 return retval;
3687}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:2068

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

Referenced by handleCommand().

◆ injectToken()

bool DocPara::injectToken ( Token tok,
const QCString & tokText )

Definition at line 4047 of file docnode.cpp.

4048{
4049 AUTO_TRACE();
4050 parser()->context.token->name = tokText;
4051 return parser()->defaultHandleToken(thisVariant(),tok,children());
4052}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token &tok, DocNodeList &children, bool handleWord=TRUE)
Definition docparser.cpp:1455

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

Referenced by DocSimpleSect::appendLinkWord().

◆ isEmpty()

bool DocPara::isEmpty ( ) const
inline

Definition at line 1093 of file docnode.h.

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

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

◆ isFirst()

bool DocPara::isFirst ( ) const
inline

Definition at line 1096 of file docnode.h.

1096{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1097 of file docnode.h.

1097{ return m_isLast; }

References m_isLast.

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

◆ markFirst()

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

Definition at line 1094 of file docnode.h.

1094{ m_isFirst=v; }

References m_isFirst, and TRUE.

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

◆ markLast()

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

Definition at line 1095 of file docnode.h.

1095{ m_isLast=v; }

References m_isLast, and TRUE.

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

◆ parse()

Token DocPara::parse ( )

Definition at line 5684 of file docnode.cpp.

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

References DocNodeList::append(), AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, TokenInfo::chars, checkIfHtmlEndTagEndsAutoList(), DocCompoundNode::children(), CMD_LI, Mappers::cmdMapper, Token::command_to_char(), DocParser::context, DocSymbol::decodeSymbol(), DocPara(), DocNodeList::get_last(), handleCommand(), handleHtmlEndTag(), handleHtmlStartTag(), DocParser::handleInitialStyleCommands(), DocParser::handleLinkedWord(), DocParser::handlePendingStyleCommands(), holds_one_of_alternatives(), DocAutoList::indent(), TokenInfo::indent, insidePRE(), INTERNAL_ASSERT, Token::is(), Token::is_any_of(), TokenInfo::isCheckedList, TokenInfo::isEMailAddr, DocAutoList::isEnumList(), TokenInfo::isEnumList, DocTokenizer::lex(), QCString::mid(), TokenInfo::name, DocNode::parent(), parse(), DocNode::parser(), DocSimpleSect::Rcs, setAttribs(), SIMPLESECT_BIT, TokenInfo::simpleSectName, TokenInfo::simpleSectText, HtmlEntityMapper::Sym_Unknown, TokenInfo::text, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Token::value(), and warn_doc_error.

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

◆ setAttribs()

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

Definition at line 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: