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

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

#include <src/docnode.h>

Inheritance diagram for DocPara:
Collaboration diagram for DocPara:

Public Member Functions

 DocPara (DocParser *parser, DocNodeVariant *parent)
Token parse ()
bool 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 3481 of file docnode.cpp.

3481 :
3482 DocCompoundNode(parser,parent),
3483 m_isFirst(false), m_isLast(false)
3484{
3485}
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

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

Referenced by parse().

Member Function Documentation

◆ attribs()

const HtmlAttribList & DocPara::attribs ( ) const
inline

Definition at line 1119 of file docnode.h.

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

References m_attribs.

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

◆ handleCommand()

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

Definition at line 4132 of file docnode.cpp.

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

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

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

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(), QCString::str(), theTranslator, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, Translator::trWriteList(), ConfigEnum::valueRef(), ConfigString::valueRef(), ConfigBool::valueStringRef(), ConfigInt::valueStringRef(), warn, and warn_doc_error.

Referenced by handleCommand().

◆ handleEmoji()

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

Definition at line 3540 of file docnode.cpp.

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

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

Referenced by handleCommand().

◆ handleFile()

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

Definition at line 3821 of file docnode.cpp.

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

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

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

Referenced by parse().

◆ handleHtmlHeader()

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

Definition at line 4037 of file docnode.cpp.

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

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

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

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

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

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

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

Referenced by handleCommand().

◆ handleInheritDoc()

void DocPara::handleInheritDoc ( )

Definition at line 4091 of file docnode.cpp.

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

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

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

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

References DocNodeList::append(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), 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 4006 of file docnode.cpp.

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

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

Referenced by handleCommand().

◆ handleShowDate()

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

Definition at line 3691 of file docnode.cpp.

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

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

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 4055 of file docnode.cpp.

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

References DocNodeList::append(), QCString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, DocCompoundNode::children(), DocVerbatim::Code, DocParser::context, DocParserContext::context, DocParserContext::exampleName, 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 3853 of file docnode.cpp.

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

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

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

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

Referenced by handleCommand().

◆ injectToken()

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

Definition at line 4048 of file docnode.cpp.

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

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.

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

◆ markLast()

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

Definition at line 1095 of file docnode.h.

1095{ m_isLast=v; }

References m_isLast.

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

◆ parse()

Token DocPara::parse ( )

Definition at line 5685 of file docnode.cpp.

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