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

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

#include <src/docnode.h>

Inheritance diagram for DocPara:
Collaboration diagram for DocPara:

Public Member Functions

 DocPara (DocParser *parser, DocNodeVariant *parent)
Token parse ()
bool isEmpty () const
void markFirst (bool v=TRUE)
void markLast (bool v=TRUE)
bool isFirst () const
bool isLast () const
Token handleCommand (char cmdChar, const QCString &cmdName)
Token handleHtmlStartTag (const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Token handleHtmlEndTag (const QCString &tagName)
Token handleSimpleSection (DocSimpleSect::Type t, bool xmlContext=FALSE)
Token handleXRefItem ()
Token handleParamSection (const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
void handleIncludeOperator (const QCString &cmdName, DocIncOperator::Type t)
template<class T>
void handleFile (const QCString &cmdName)
void handleInclude (const QCString &cmdName, DocInclude::Type t)
void handleLink (const QCString &cmdName, bool isJavaLink)
void handleCite (char cmdChar, const QCString &cmdName)
void handleDoxyConfig (char cmdChar, const QCString &cmdName)
void handleEmoji (char cmdChar, const QCString &cmdName)
void handleRef (char cmdChar, const QCString &cmdName)
void handleSection (char cmdChar, const QCString &cmdName)
void handleInheritDoc ()
void handleVhdlFlow ()
void handleILine (char cmdChar, const QCString &cmdName)
void handleIFile (char cmdChar, const QCString &cmdName)
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 }
Protected Member Functions inherited from DocNode
void setInsidePreformatted (bool p)

Detailed Description

Node representing a paragraph in the documentation tree.

Definition at line 1074 of file docnode.h.

Constructor & Destructor Documentation

◆ DocPara()

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

Definition at line 3242 of file docnode.cpp.

3242 :
3243 DocCompoundNode(parser,parent),
3244 m_isFirst(FALSE), m_isLast(FALSE)
3245{
3246}
DocCompoundNode::DocCompoundNode
DocCompoundNode(DocParser *parser, DocNodeVariant *parent)
Definition docnode.h:140
DocNode::parser
DocParser * parser()
Definition docnode.h:97
DocNode::parent
DocNodeVariant * parent()
Definition docnode.h:89
DocPara::m_isFirst
bool m_isFirst
Definition docnode.h:1113
DocPara::m_isLast
bool m_isLast
Definition docnode.h:1114
FALSE
#define FALSE
Definition qcstring.h:34

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

Referenced by parse().

Member Function Documentation

◆ attribs()

const HtmlAttribList & DocPara::attribs ( ) const
inline

Definition at line 1109 of file docnode.h.

1109{ return m_attribs; }
DocPara::m_attribs
HtmlAttribList m_attribs
Definition docnode.h:1115

References m_attribs.

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

◆ handleCite()

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

Definition at line 3301 of file docnode.cpp.

3302{
3303 AUTO_TRACE();
3304 // get the argument of the cite command.
3305 Token tok=parser()->tokenizer.lex();
3306 if (!tok.is(TokenRetval::TK_WHITESPACE))
3307 {
3308 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3309 cmdChar,cmdName);
3310 return;
3311 }
3312 parser()->tokenizer.setStateCite();
3313 tok=parser()->tokenizer.lex();
3314 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3315 {
3316 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3317 "argument of command '{:c}{}'",cmdChar,cmdName);
3318 return;
3319 }
3320 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3321 {
3322 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3323 tok.to_string(),cmdChar,cmdName);
3324 return;
3325 }
3326 parser()->context.token->sectionId = parser()->context.token->name;
3327 children().append<DocCite>(
3328 parser(),thisVariant(),parser()->context.token->name,parser()->context.context);
3329
3330 parser()->tokenizer.setStatePara();
3331}
DocCompoundNode::children
DocNodeList & children()
Definition docnode.h:142
DocNode::thisVariant
DocNodeVariant * thisVariant()
Definition docnode.h:92
DocParser::tokenizer
DocTokenizer tokenizer
Definition docparser_p.h:141
DocParser::context
DocParserContext context
Definition docparser_p.h:140
DocTokenizer::setStateCite
void setStateCite()
Definition doctokenizer.l:2032
DocTokenizer::setStatePara
void setStatePara()
Definition doctokenizer.l:1826
Token::is
bool is(TokenRetval rv) const
Definition doctokenizer.h:120
Token::to_string
TOKEN_SPECIFICATIONS RETVAL_SPECIFICATIONS const char * to_string() const
Definition doctokenizer.h:91
Token::is_any_of
bool is_any_of(ARGS... args) const
Definition doctokenizer.h:115
AUTO_TRACE
#define AUTO_TRACE(...)
Definition docnode.cpp:46
warn_doc_error
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
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:1394
DocParserContext::token
TokenInfo * token
Definition docparser_p.h:92
TokenInfo::sectionId
QCString sectionId
Definition doctokenizer.h:149
TokenInfo::name
QCString name
Definition doctokenizer.h:136

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

Referenced by handleCommand().

◆ handleCommand()

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

Definition at line 3985 of file docnode.cpp.

3986{
3987 AUTO_TRACE("cmdName={}",cmdName);
3988 Token retval = Token::make_RetVal_OK();
3989 CommandType cmdId = Mappers::cmdMapper->map(cmdName);
3990 switch (cmdId)
3991 {
3992 case CommandType::UNKNOWN:
3993 {
3994 std::string str{cmdChar};
3995 children().append<DocWord>(parser(),thisVariant(),str.c_str() + cmdName);
3996 if (isAliasCmd(cmdName.view()))
3997 {
3998 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unexpanded alias '{:c}{}'. Check if number of arguments passed is correct.",cmdChar,cmdName);
3999 }
4000 else
4001 {
4002 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Found unknown command '{:c}{}'",cmdChar,cmdName);
4003 }
4004 }
4005 break;
4006 case CommandType::CMD_EMPHASIS:
4007 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,TRUE);
4008 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4009 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,cmdName,FALSE);
4010 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4011 break;
4012 case CommandType::CMD_BOLD:
4013 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,TRUE);
4014 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4015 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Bold,cmdName,FALSE);
4016 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4017 break;
4018 case CommandType::CMD_CODE:
4019 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,TRUE);
4020 retval=parser()->handleStyleArgument(thisVariant(),children(),cmdName);
4021 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,cmdName,FALSE);
4022 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
4023 break;
4024 case CommandType::CMD_BSLASH:
4025 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_BSlash);
4026 break;
4027 case CommandType::CMD_AT:
4028 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_At);
4029 break;
4030 case CommandType::CMD_LESS:
4031 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Less);
4032 break;
4033 case CommandType::CMD_GREATER:
4034 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Greater);
4035 break;
4036 case CommandType::CMD_AMP:
4037 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Amp);
4038 break;
4039 case CommandType::CMD_DOLLAR:
4040 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Dollar);
4041 break;
4042 case CommandType::CMD_HASH:
4043 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Hash);
4044 break;
4045 case CommandType::CMD_PIPE:
4046 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Pipe);
4047 break;
4048 case CommandType::CMD_DCOLON:
4049 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_DoubleColon);
4050 break;
4051 case CommandType::CMD_PERCENT:
4052 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Percent);
4053 break;
4054 case CommandType::CMD_NDASH:
4055 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4056 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4057 break;
4058 case CommandType::CMD_MDASH:
4059 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4060 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4061 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4062 break;
4063 case CommandType::CMD_QUOTE:
4064 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Quot);
4065 break;
4066 case CommandType::CMD_PUNT:
4067 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Dot);
4068 break;
4069 case CommandType::CMD_EXCLAMATION:
4070 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Exclam);
4071 break;
4072 case CommandType::CMD_QUESTION:
4073 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Quest);
4074 break;
4075 case CommandType::CMD_PLUS:
4076 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Plus);
4077 break;
4078 case CommandType::CMD_MINUS:
4079 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Minus);
4080 break;
4081 case CommandType::CMD_EQUAL:
4082 children().append<DocSymbol>(parser(),thisVariant(),HtmlEntityMapper::Sym_Equal);
4083 break;
4084 case CommandType::CMD_SA:
4085 parser()->context.inSeeBlock=TRUE;
4086 retval = handleSimpleSection(DocSimpleSect::See);
4087 parser()->context.inSeeBlock=FALSE;
4088 break;
4089 case CommandType::CMD_RETURN:
4090 retval = handleSimpleSection(DocSimpleSect::Return);
4091 parser()->context.hasReturnCommand=TRUE;
4092 break;
4093 case CommandType::CMD_AUTHOR:
4094 retval = handleSimpleSection(DocSimpleSect::Author);
4095 break;
4096 case CommandType::CMD_AUTHORS:
4097 retval = handleSimpleSection(DocSimpleSect::Authors);
4098 break;
4099 case CommandType::CMD_VERSION:
4100 retval = handleSimpleSection(DocSimpleSect::Version);
4101 break;
4102 case CommandType::CMD_SINCE:
4103 retval = handleSimpleSection(DocSimpleSect::Since);
4104 break;
4105 case CommandType::CMD_DATE:
4106 retval = handleSimpleSection(DocSimpleSect::Date);
4107 break;
4108 case CommandType::CMD_NOTE:
4109 retval = handleSimpleSection(DocSimpleSect::Note);
4110 break;
4111 case CommandType::CMD_WARNING:
4112 retval = handleSimpleSection(DocSimpleSect::Warning);
4113 break;
4114 case CommandType::CMD_PRE:
4115 retval = handleSimpleSection(DocSimpleSect::Pre);
4116 break;
4117 case CommandType::CMD_POST:
4118 retval = handleSimpleSection(DocSimpleSect::Post);
4119 break;
4120 case CommandType::CMD_COPYRIGHT:
4121 retval = handleSimpleSection(DocSimpleSect::Copyright);
4122 break;
4123 case CommandType::CMD_INVARIANT:
4124 retval = handleSimpleSection(DocSimpleSect::Invar);
4125 break;
4126 case CommandType::CMD_REMARK:
4127 retval = handleSimpleSection(DocSimpleSect::Remark);
4128 break;
4129 case CommandType::CMD_ATTENTION:
4130 retval = handleSimpleSection(DocSimpleSect::Attention);
4131 break;
4132 case CommandType::CMD_IMPORTANT:
4133 retval = handleSimpleSection(DocSimpleSect::Important);
4134 break;
4135 case CommandType::CMD_PAR:
4136 retval = handleSimpleSection(DocSimpleSect::User);
4137 break;
4138 case CommandType::CMD_LI:
4139 {
4140 children().append<DocSimpleList>(parser(),thisVariant());
4141 retval = children().get_last<DocSimpleList>()->parse();
4142 }
4143 break;
4144 case CommandType::CMD_SECTION:
4145 {
4146 handleSection(cmdChar,cmdName);
4147 retval = Token::make_RetVal_Section();
4148 }
4149 break;
4150 case CommandType::CMD_SUBSECTION:
4151 {
4152 handleSection(cmdChar,cmdName);
4153 retval = Token::make_RetVal_Subsection();
4154 }
4155 break;
4156 case CommandType::CMD_SUBSUBSECTION:
4157 {
4158 handleSection(cmdChar,cmdName);
4159 retval = Token::make_RetVal_Subsubsection();
4160 }
4161 break;
4162 case CommandType::CMD_PARAGRAPH:
4163 {
4164 handleSection(cmdChar,cmdName);
4165 retval = Token::make_RetVal_Paragraph();
4166 }
4167 break;
4168 case CommandType::CMD_SUBPARAGRAPH:
4169 {
4170 handleSection(cmdChar,cmdName);
4171 retval = Token::make_RetVal_SubParagraph();
4172 }
4173 break;
4174 case CommandType::CMD_SUBSUBPARAGRAPH:
4175 {
4176 handleSection(cmdChar,cmdName);
4177 retval = Token::make_RetVal_SubSubParagraph();
4178 }
4179 break;
4180 case CommandType::CMD_ISTARTCODE:
4181 {
4182 parser()->tokenizer.setStateICode();
4183 retval = handleStartCode();
4184 }
4185 break;
4186 case CommandType::CMD_STARTCODE:
4187 {
4188 parser()->tokenizer.setStateCode();
4189 retval = handleStartCode();
4190 }
4191 break;
4192 case CommandType::CMD_HTMLONLY:
4193 {
4194 parser()->tokenizer.setStateHtmlOnly();
4195 retval = parser()->tokenizer.lex();
4196 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");
4197 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4198 {
4199 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"htmlonly section ended without end marker");
4200 }
4201 parser()->tokenizer.setStatePara();
4202 }
4203 break;
4204 case CommandType::CMD_MANONLY:
4205 {
4206 parser()->tokenizer.setStateManOnly();
4207 retval = parser()->tokenizer.lex();
4208 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::ManOnly,parser()->context.isExample,parser()->context.exampleName);
4209 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4210 {
4211 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"manonly section ended without end marker");
4212 }
4213 parser()->tokenizer.setStatePara();
4214 }
4215 break;
4216 case CommandType::CMD_RTFONLY:
4217 {
4218 parser()->tokenizer.setStateRtfOnly();
4219 retval = parser()->tokenizer.lex();
4220 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::RtfOnly,parser()->context.isExample,parser()->context.exampleName);
4221 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4222 {
4223 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"rtfonly section ended without end marker");
4224 }
4225 parser()->tokenizer.setStatePara();
4226 }
4227 break;
4228 case CommandType::CMD_LATEXONLY:
4229 {
4230 parser()->tokenizer.setStateLatexOnly();
4231 retval = parser()->tokenizer.lex();
4232 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::LatexOnly,parser()->context.isExample,parser()->context.exampleName);
4233 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4234 {
4235 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"latexonly section ended without end marker");
4236 }
4237 parser()->tokenizer.setStatePara();
4238 }
4239 break;
4240 case CommandType::CMD_XMLONLY:
4241 {
4242 parser()->tokenizer.setStateXmlOnly();
4243 retval = parser()->tokenizer.lex();
4244 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::XmlOnly,parser()->context.isExample,parser()->context.exampleName);
4245 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4246 {
4247 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"xmlonly section ended without end marker");
4248 }
4249 parser()->tokenizer.setStatePara();
4250 }
4251 break;
4252 case CommandType::CMD_DBONLY:
4253 {
4254 parser()->tokenizer.setStateDbOnly();
4255 retval = parser()->tokenizer.lex();
4256 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::DocbookOnly,parser()->context.isExample,parser()->context.exampleName);
4257 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4258 {
4259 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"docbookonly section ended without end marker");
4260 }
4261 parser()->tokenizer.setStatePara();
4262 }
4263 break;
4264 case CommandType::CMD_ILITERAL:
4265 {
4266 DocVerbatim::Type t = DocVerbatim::JavaDocLiteral;
4267 parser()->tokenizer.setStateILiteralOpt();
4268 parser()->tokenizer.lex();
4269
4270 QCString fullMatch = parser()->context.token->verb;
4271 int idx = fullMatch.find('{');
4272 int idxEnd = fullMatch.find("}",idx+1);
4273 StringVector optList;
4274 if (idx != -1) // options present
4275 {
4276 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4277 optList = split(optStr.str(),",");
4278 for (const auto &opt : optList)
4279 {
4280 if (opt.empty()) continue;
4281 QCString locOpt(opt);
4282 locOpt = locOpt.stripWhiteSpace().lower();
4283 if (locOpt == "code")
4284 {
4285 t = DocVerbatim::JavaDocCode;
4286 }
4287 else if (!locOpt.isEmpty())
4288 {
4289 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option '{}' for '\\iliteral'",opt);
4290 }
4291 }
4292 }
4293
4294 parser()->tokenizer.setStateILiteral();
4295 retval = parser()->tokenizer.lex();
4296 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,t,parser()->context.isExample,parser()->context.exampleName);
4297 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4298 {
4299 if (t == DocVerbatim::JavaDocCode)
4300 {
4301 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc code section ended without end marker");
4302 }
4303 else
4304 {
4305 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"javadoc literal section ended without end marker");
4306 }
4307 }
4308 parser()->tokenizer.setStatePara();
4309 }
4310 break;
4311 case CommandType::CMD_IVERBATIM:
4312 case CommandType::CMD_VERBATIM:
4313 {
4314 if (cmdId == CommandType::CMD_VERBATIM)
4315 {
4316 parser()->tokenizer.setStateVerbatim();
4317 }
4318 else
4319 {
4320 parser()->tokenizer.setStateIVerbatim();
4321 }
4322 retval = parser()->tokenizer.lex();
4323 children().append<DocVerbatim>(parser(),thisVariant(),parser()->context.context,parser()->context.token->verb,DocVerbatim::Verbatim,parser()->context.isExample,parser()->context.exampleName);
4324 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4325 {
4326 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"verbatim section ended without end marker");
4327 }
4328 parser()->tokenizer.setStatePara();
4329 }
4330 break;
4331 case CommandType::CMD_DOT:
4332 {
4333 children().append<DocVerbatim>(parser(),thisVariant(),
4334 parser()->context.context,
4335 parser()->context.token->verb,
4336 DocVerbatim::Dot,
4337 parser()->context.isExample,
4338 parser()->context.exampleName);
4339 DocVerbatim *dv = children().get_last<DocVerbatim>();
4340 parser()->tokenizer.setStatePara();
4341 QCString width,height;
4342 parser()->defaultHandleTitleAndSize(CommandType::CMD_DOT,&children().back(),dv->children(),width,height);
4343 parser()->tokenizer.setStateDot();
4344 retval = parser()->tokenizer.lex();
4345 dv->setText(parser()->context.token->verb);
4346 dv->setWidth(width);
4347 dv->setHeight(height);
4348 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4349 if (!Config_getBool(HAVE_DOT))
4350 {
4351 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\dot command because HAVE_DOT is not set");
4352 children().pop_back();
4353 }
4354 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4355 {
4356 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"dot section ended without end marker");
4357 }
4358 parser()->tokenizer.setStatePara();
4359 }
4360 break;
4361 case CommandType::CMD_MSC:
4362 {
4363 children().append<DocVerbatim>(parser(),thisVariant(),
4364 parser()->context.context,
4365 parser()->context.token->verb,
4366 DocVerbatim::Msc,
4367 parser()->context.isExample,
4368 parser()->context.exampleName);
4369 DocVerbatim *dv = children().get_last<DocVerbatim>();
4370 parser()->tokenizer.setStatePara();
4371 QCString width,height;
4372 parser()->defaultHandleTitleAndSize(CommandType::CMD_MSC,&children().back(),dv->children(),width,height);
4373 parser()->tokenizer.setStateMsc();
4374 retval = parser()->tokenizer.lex();
4375 dv->setText(parser()->context.token->verb);
4376 dv->setWidth(width);
4377 dv->setHeight(height);
4378 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4379 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4380 {
4381 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"msc section ended without end marker");
4382 }
4383 parser()->tokenizer.setStatePara();
4384 }
4385 break;
4386 case CommandType::CMD_STARTUML:
4387 {
4388 QCString jarPath = Config_getString(PLANTUML_JAR_PATH);
4389 parser()->tokenizer.setStatePlantUMLOpt();
4390 parser()->tokenizer.lex();
4391 QCString fullMatch = parser()->context.token->sectionId;
4392 QCString sectionId = "";
4393 int idx = fullMatch.find('{');
4394 int idxEnd = fullMatch.find("}",idx+1);
4395 StringVector optList;
4396 QCString engine;
4397 if (idx != -1) // options present
4398 {
4399 QCString optStr = fullMatch.mid(idx+1,idxEnd-idx-1).stripWhiteSpace();
4400 optList = split(optStr.str(),",");
4401 for (const auto &opt : optList)
4402 {
4403 if (opt.empty()) continue;
4404 bool found = false;
4405 QCString locOpt(opt);
4406 locOpt = locOpt.stripWhiteSpace().lower();
4407 if (g_plantumlEngine.find(locOpt.str())!=g_plantumlEngine.end())
4408 {
4409 if (!engine.isEmpty())
4410 {
4411 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Multiple definition of engine for '\\startuml'");
4412 }
4413 engine = locOpt;
4414 found = true;
4415 }
4416 if (!found)
4417 {
4418 if (sectionId.isEmpty())
4419 {
4420 sectionId = opt;
4421 }
4422 else
4423 {
4424 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Multiple use of filename for '\\startuml'");
4425 }
4426 }
4427 }
4428 }
4429 else
4430 {
4431 sectionId = parser()->context.token->sectionId;
4432 }
4433 if (engine.isEmpty()) engine = "uml";
4434
4435 if (sectionId.isEmpty())
4436 {
4437 parser()->tokenizer.setStatePlantUMLOpt();
4438 retval = parser()->tokenizer.lex();
4439 assert(retval.is(TokenRetval::RetVal_OK));
4440
4441 sectionId = parser()->context.token->sectionId;
4442 sectionId = sectionId.stripWhiteSpace();
4443 }
4444
4445 QCString plantFile(sectionId);
4446 children().append<DocVerbatim>(parser(),thisVariant(),
4447 parser()->context.context,
4448 parser()->context.token->verb,
4449 DocVerbatim::PlantUML,
4450 FALSE,plantFile);
4451 DocVerbatim *dv = children().get_last<DocVerbatim>();
4452 dv->setEngine(engine);
4453 parser()->tokenizer.setStatePara();
4454 QCString width,height;
4455 parser()->defaultHandleTitleAndSize(CommandType::CMD_STARTUML,&children().back(),dv->children(),width,height);
4456 parser()->tokenizer.setStatePlantUML();
4457 retval = parser()->tokenizer.lex();
4458 int line = 0;
4459 QCString trimmedVerb = stripLeadingAndTrailingEmptyLines(parser()->context.token->verb,line);
4460 if (engine == "ditaa")
4461 {
4462 dv->setUseBitmap(true);
4463 }
4464 else if (engine == "uml")
4465 {
4466 int i = trimmedVerb.find('\n');
4467 QCString firstLine = i==-1 ? trimmedVerb : trimmedVerb.left(i);
4468 if (firstLine.stripWhiteSpace() == "ditaa") dv->setUseBitmap(true);
4469 }
4470 dv->setText(trimmedVerb);
4471 dv->setWidth(width);
4472 dv->setHeight(height);
4473 dv->setLocation(parser()->context.fileName,parser()->tokenizer.getLineNr());
4474 if (jarPath.isEmpty())
4475 {
4476 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"ignoring \\startuml command because PLANTUML_JAR_PATH is not set");
4477 children().pop_back();
4478 }
4479 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
4480 {
4481 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"startuml section ended without end marker");
4482 }
4483 parser()->tokenizer.setStatePara();
4484 }
4485 break;
4486 case CommandType::CMD_ENDPARBLOCK:
4487 retval = Token::make_RetVal_EndParBlock();
4488 break;
4489 case CommandType::CMD_ENDICODE:
4490 case CommandType::CMD_ENDCODE:
4491 case CommandType::CMD_ENDHTMLONLY:
4492 case CommandType::CMD_ENDMANONLY:
4493 case CommandType::CMD_ENDRTFONLY:
4494 case CommandType::CMD_ENDLATEXONLY:
4495 case CommandType::CMD_ENDXMLONLY:
4496 case CommandType::CMD_ENDDBONLY:
4497 case CommandType::CMD_ENDLINK:
4498 case CommandType::CMD_ENDVERBATIM:
4499 case CommandType::CMD_ENDIVERBATIM:
4500 case CommandType::CMD_ENDILITERAL:
4501 case CommandType::CMD_ENDDOT:
4502 case CommandType::CMD_ENDMSC:
4503 case CommandType::CMD_ENDUML:
4504 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4505 break;
4506 case CommandType::CMD_PARAM:
4507 retval = handleParamSection(cmdName,DocParamSect::Param,FALSE,parser()->context.token->paramDir);
4508 break;
4509 case CommandType::CMD_TPARAM:
4510 retval = handleParamSection(cmdName,DocParamSect::TemplateParam,FALSE,parser()->context.token->paramDir);
4511 break;
4512 case CommandType::CMD_RETVAL:
4513 retval = handleParamSection(cmdName,DocParamSect::RetVal);
4514 break;
4515 case CommandType::CMD_EXCEPTION:
4516 retval = handleParamSection(cmdName,DocParamSect::Exception);
4517 break;
4518 case CommandType::CMD_XREFITEM:
4519 retval = handleXRefItem();
4520 break;
4521 case CommandType::CMD_LINEBREAK:
4522 {
4523 children().append<DocLineBreak>(parser(),thisVariant());
4524 }
4525 break;
4526 case CommandType::CMD_IANCHOR:
4527 case CommandType::CMD_ANCHOR:
4528 {
4529 parser()->handleAnchor(thisVariant(),children());
4530 }
4531 break;
4532 case CommandType::CMD_IPREFIX:
4533 {
4534 parser()->handlePrefix(thisVariant(),children());
4535 }
4536 break;
4537 case CommandType::CMD_ADDINDEX:
4538 {
4539 children().append<DocIndexEntry>(parser(),thisVariant(),
4540 parser()->context.scope!=Doxygen::globalScope?parser()->context.scope:nullptr,
4541 parser()->context.memberDef);
4542 retval = children().get_last<DocIndexEntry>()->parse();
4543 }
4544 break;
4545 case CommandType::CMD_INTERNAL:
4546 retval = Token::make_RetVal_Internal();
4547 break;
4548 case CommandType::CMD_ENDINTERNAL:
4549 retval = Token::make_RetVal_EndInternal();
4550 break;
4551 case CommandType::CMD_PARBLOCK:
4552 {
4553 children().append<DocParBlock>(parser(),thisVariant());
4554 retval = children().get_last<DocParBlock>()->parse();
4555 }
4556 break;
4557 case CommandType::CMD_COPYDOC: // fall through
4558 case CommandType::CMD_COPYBRIEF: // fall through
4559 case CommandType::CMD_COPYDETAILS:
4560 //retval = Token::make_RetVal_CopyDoc();
4561 // these commands should already be resolved by processCopyDoc()
4562 break;
4563 case CommandType::CMD_INCLUDE:
4564 handleInclude(cmdName,DocInclude::Include);
4565 break;
4566 case CommandType::CMD_INCWITHLINES:
4567 handleInclude(cmdName,DocInclude::IncWithLines);
4568 break;
4569 case CommandType::CMD_DONTINCLUDE:
4570 handleInclude(cmdName,DocInclude::DontInclude);
4571 break;
4572 case CommandType::CMD_HTMLINCLUDE:
4573 handleInclude(cmdName,DocInclude::HtmlInclude);
4574 break;
4575 case CommandType::CMD_LATEXINCLUDE:
4576 handleInclude(cmdName,DocInclude::LatexInclude);
4577 break;
4578 case CommandType::CMD_RTFINCLUDE:
4579 handleInclude(cmdName,DocInclude::RtfInclude);
4580 break;
4581 case CommandType::CMD_MANINCLUDE:
4582 handleInclude(cmdName,DocInclude::ManInclude);
4583 break;
4584 case CommandType::CMD_XMLINCLUDE:
4585 handleInclude(cmdName,DocInclude::XmlInclude);
4586 break;
4587 case CommandType::CMD_DOCBOOKINCLUDE:
4588 handleInclude(cmdName,DocInclude::DocbookInclude);
4589 break;
4590 case CommandType::CMD_VERBINCLUDE:
4591 handleInclude(cmdName,DocInclude::VerbInclude);
4592 break;
4593 case CommandType::CMD_SNIPPET:
4594 handleInclude(cmdName,DocInclude::Snippet);
4595 break;
4596 case CommandType::CMD_SNIPWITHLINES:
4597 handleInclude(cmdName,DocInclude::SnippetWithLines);
4598 break;
4599 case CommandType::CMD_SKIP:
4600 handleIncludeOperator(cmdName,DocIncOperator::Skip);
4601 break;
4602 case CommandType::CMD_UNTIL:
4603 handleIncludeOperator(cmdName,DocIncOperator::Until);
4604 break;
4605 case CommandType::CMD_SKIPLINE:
4606 handleIncludeOperator(cmdName,DocIncOperator::SkipLine);
4607 break;
4608 case CommandType::CMD_LINE:
4609 handleIncludeOperator(cmdName,DocIncOperator::Line);
4610 break;
4611 case CommandType::CMD_IMAGE:
4612 parser()->handleImage(thisVariant(),children());
4613 break;
4614 case CommandType::CMD_DOTFILE:
4615 if (!Config_getBool(HAVE_DOT))
4616 {
4617 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
4618 "ignoring \\dotfile command because HAVE_DOT is not set");
4619 }
4620 else
4621 {
4622 handleFile<DocDotFile>(cmdName);
4623 }
4624 break;
4625 case CommandType::CMD_VHDLFLOW:
4626 handleVhdlFlow();
4627 break;
4628 case CommandType::CMD_MSCFILE:
4629 handleFile<DocMscFile>(cmdName);
4630 break;
4631 case CommandType::CMD_DIAFILE:
4632 handleFile<DocDiaFile>(cmdName);
4633 break;
4634 case CommandType::CMD_PLANTUMLFILE:
4635 handleFile<DocPlantUmlFile>(cmdName);
4636 break;
4637 case CommandType::CMD_LINK:
4638 handleLink(cmdName,FALSE);
4639 break;
4640 case CommandType::CMD_JAVALINK:
4641 handleLink(cmdName,TRUE);
4642 break;
4643 case CommandType::CMD_CITE:
4644 handleCite(cmdChar,cmdName);
4645 break;
4646 case CommandType::CMD_EMOJI:
4647 handleEmoji(cmdChar,cmdName);
4648 break;
4649 case CommandType::CMD_DOXYCONFIG:
4650 handleDoxyConfig(cmdChar,cmdName);
4651 break;
4652 case CommandType::CMD_REF: // fall through
4653 case CommandType::CMD_SUBPAGE:
4654 handleRef(cmdChar,cmdName);
4655 break;
4656 case CommandType::CMD_SECREFLIST:
4657 {
4658 children().append<DocSecRefList>(parser(),thisVariant());
4659 children().get_last<DocSecRefList>()->parse();
4660 }
4661 break;
4662 case CommandType::CMD_SECREFITEM:
4663 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4664 break;
4665 case CommandType::CMD_ENDSECREFLIST:
4666 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command '{:c}{}'",cmdChar,parser()->context.token->name);
4667 break;
4668 case CommandType::CMD_FORMULA:
4669 {
4670 children().append<DocFormula>(parser(),thisVariant(),parser()->context.token->id);
4671 }
4672 break;
4673 //case CommandType::CMD_LANGSWITCH:
4674 // retval = handleLanguageSwitch();
4675 // break;
4676 case CommandType::CMD_INTERNALREF:
4677 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected command {}",parser()->context.token->name);
4678 {
4679 parser()->handleInternalRef(thisVariant(),children());
4680 parser()->tokenizer.setStatePara();
4681 }
4682 break;
4683 case CommandType::CMD_INHERITDOC:
4684 handleInheritDoc();
4685 break;
4686 case CommandType::CMD_SHOWDATE:
4687 handleShowDate(cmdChar,cmdName);
4688 break;
4689 case CommandType::CMD_ILINE:
4690 handleILine(cmdChar,cmdName);
4691 break;
4692 case CommandType::CMD_IFILE:
4693 handleIFile(cmdChar,cmdName);
4694 break;
4695 case CommandType::CMD_SETSCOPE:
4696 {
4697 parser()->tokenizer.setStateSetScope();
4698 (void)parser()->tokenizer.lex();
4699 parser()->context.context = parser()->context.token->name;
4700 //printf("Found scope='%s'\n",qPrint(parser()->context.context));
4701 parser()->tokenizer.setStatePara();
4702 }
4703 break;
4704 default:
4705 // we should not get here!
4706 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected command '{}' in paragraph context",cmdName);
4707 break;
4708 }
4709 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::RetVal_OK,TokenRetval::RetVal_SimpleSec
4710 TokenRetval::TK_LISTITEM,TokenRetval::TK_ENDLIST,TokenRetval::TK_NEWPARA
4711 TokenRetval::RetVal_Section,TokenRetval::RetVal_EndList
4712 TokenRetval::RetVal_Internal,TokenRetval::RetVal_SwitchLang
4713 TokenRetval::RetVal_EndInternal)
4714 );
4715 AUTO_TRACE_EXIT("retval={}",retval.to_string());
4716 return retval;
4717}
isAliasCmd
bool isAliasCmd(std::string_view aliasCmd)
Definition aliases.cpp:528
DocInclude::LatexInclude
@ LatexInclude
Definition docnode.h:433
DocInclude::SnippetWithLines
@ SnippetWithLines
Definition docnode.h:434
DocInclude::IncWithLines
@ IncWithLines
Definition docnode.h:434
DocInclude::HtmlInclude
@ HtmlInclude
Definition docnode.h:433
DocInclude::VerbInclude
@ VerbInclude
Definition docnode.h:433
DocInclude::DontInclude
@ DontInclude
Definition docnode.h:433
DocInclude::DocbookInclude
@ DocbookInclude
Definition docnode.h:435
DocPara::handleSimpleSection
Token handleSimpleSection(DocSimpleSect::Type t, bool xmlContext=FALSE)
Definition docnode.cpp:3248
DocPara::handleLink
void handleLink(const QCString &cmdName, bool isJavaLink)
Definition docnode.cpp:3690
DocPara::handleInheritDoc
void handleInheritDoc()
Definition docnode.cpp:3948
DocPara::handleCite
void handleCite(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3301
DocPara::handleInclude
void handleInclude(const QCString &cmdName, DocInclude::Type t)
Definition docnode.cpp:3758
DocPara::handleDoxyConfig
void handleDoxyConfig(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3364
DocPara::handleSection
void handleSection(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3863
DocPara::handleFile
void handleFile(const QCString &cmdName)
Definition docnode.cpp:3651
DocPara::handleIFile
void handleIFile(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3567
DocPara::handleParamSection
Token handleParamSection(const QCString &cmdName, DocParamSect::Type t, bool xmlContext, int direction)
Definition docnode.cpp:3278
DocPara::handleEmoji
void handleEmoji(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3333
DocPara::handleIncludeOperator
void handleIncludeOperator(const QCString &cmdName, DocIncOperator::Type t)
Definition docnode.cpp:3591
DocPara::handleRef
void handleRef(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3731
DocPara::handleILine
void handleILine(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3553
DocPara::parse
Token parse()
Definition docnode.cpp:5479
DocPara::handleVhdlFlow
void handleVhdlFlow()
Definition docnode.cpp:3683
DocPara::handleShowDate
void handleShowDate(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3483
DocPara::handleXRefItem
Token handleXRefItem()
Definition docnode.cpp:3462
DocPara::handleStartCode
Token handleStartCode()
Definition docnode.cpp:3912
DocParser::handleInternalRef
void handleInternalRef(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:921
DocParser::handleImage
void handleImage(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:1091
DocParser::handlePrefix
void handlePrefix(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:971
DocParser::handleStyleArgument
Token handleStyleArgument(DocNodeVariant *parent, DocNodeList &children, const QCString &cmdName)
Definition docparser.cpp:569
DocParser::handleAnchor
void handleAnchor(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:943
DocParser::defaultHandleTitleAndSize
void defaultHandleTitleAndSize(const CommandType cmd, DocNodeVariant *parent, DocNodeList &children, QCString &width, QCString &height)
Definition docparser.cpp:1007
DocTokenizer::setStateILiteralOpt
void setStateILiteralOpt()
Definition doctokenizer.l:1932
DocTokenizer::setStateILiteral
void setStateILiteral()
Definition doctokenizer.l:1924
DocTokenizer::setStateCode
void setStateCode()
Definition doctokenizer.l:1848
DocTokenizer::setStatePlantUMLOpt
void setStatePlantUMLOpt()
Definition doctokenizer.l:1972
DocTokenizer::setStateRtfOnly
void setStateRtfOnly()
Definition doctokenizer.l:1892
DocTokenizer::setStateVerbatim
void setStateVerbatim()
Definition doctokenizer.l:1940
DocTokenizer::setStateLatexOnly
void setStateLatexOnly()
Definition doctokenizer.l:1916
DocTokenizer::setStateManOnly
void setStateManOnly()
Definition doctokenizer.l:1884
DocTokenizer::setStateDbOnly
void setStateDbOnly()
Definition doctokenizer.l:1908
DocTokenizer::setStateHtmlOnly
void setStateHtmlOnly()
Definition doctokenizer.l:1875
DocTokenizer::setStateICode
void setStateICode()
Definition doctokenizer.l:1857
DocTokenizer::setStatePlantUML
void setStatePlantUML()
Definition doctokenizer.l:1981
DocTokenizer::setStateIVerbatim
void setStateIVerbatim()
Definition doctokenizer.l:1948
DocTokenizer::setStateXmlOnly
void setStateXmlOnly()
Definition doctokenizer.l:1900
DocTokenizer::setStateSetScope
void setStateSetScope()
Definition doctokenizer.l:2096
DocVerbatim::JavaDocLiteral
@ JavaDocLiteral
Definition docnode.h:374
Doxygen::globalScope
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
GrowVector::pop_back
void pop_back()
removes the last element
Definition growvector.h:115
QCString::find
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString::mid
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:226
QCString::isEmpty
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:150
QCString::stripWhiteSpace
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:245
QCString::str
const std::string & str() const
Definition qcstring.h:537
QCString::view
std::string_view view() const
Definition qcstring.h:161
QCString::left
QCString left(size_t len) const
Definition qcstring.h:214
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
g_plantumlEngine
static const StringUnorderedSet g_plantumlEngine
Definition docnode.cpp:69
INTERNAL_ASSERT
#define INTERNAL_ASSERT(x)
Definition docnode.cpp:51
AUTO_TRACE_EXIT
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:48
warn
#define warn(file, line, fmt,...)
Definition message.h:97
Mappers::cmdMapper
const Mapper< CommandType > * cmdMapper
Definition cmdmapper.cpp:250
TRUE
#define TRUE
Definition qcstring.h:37
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:1405
DocParserContext::nodeStack
DocNodeStack nodeStack
Definition docparser_p.h:66
DocParserContext::exampleName
QCString exampleName
Definition docparser_p.h:79
DocParserContext::scope
const Definition * scope
Definition docparser_p.h:61
DocParserContext::memberDef
const MemberDef * memberDef
Definition docparser_p.h:77
TokenInfo::verb
QCString verb
Definition doctokenizer.h:156
found
bool found
Definition util.cpp:984
split
StringVector split(const std::string &s, const std::string &delimiter)
split input string s by string delimiter delimiter.
Definition util.cpp:7095
stripLeadingAndTrailingEmptyLines
QCString stripLeadingAndTrailingEmptyLines(const QCString &s, int &docLine)
Special version of QCString::stripWhiteSpace() that only strips completely blank lines.
Definition util.cpp:5540

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_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_MINUS, CMD_MSC, CMD_MSCFILE, CMD_NDASH, CMD_NOTE, CMD_PAR, CMD_PARAGRAPH, CMD_PARAM, CMD_PARBLOCK, CMD_PERCENT, CMD_PIPE, CMD_PLANTUMLFILE, CMD_PLUS, CMD_POST, CMD_PRE, CMD_PUNT, CMD_QUESTION, CMD_QUOTE, CMD_REF, CMD_REMARK, CMD_RETURN, CMD_RETVAL, CMD_RTFINCLUDE, CMD_RTFONLY, CMD_SA, CMD_SECREFITEM, CMD_SECREFLIST, CMD_SECTION, CMD_SETSCOPE, CMD_SHOWDATE, CMD_SINCE, CMD_SKIP, CMD_SKIPLINE, CMD_SNIPPET, CMD_SNIPWITHLINES, CMD_STARTCODE, CMD_STARTUML, CMD_SUBPAGE, CMD_SUBPARAGRAPH, CMD_SUBSECTION, CMD_SUBSUBPARAGRAPH, CMD_SUBSUBSECTION, CMD_TPARAM, CMD_UNTIL, CMD_VERBATIM, CMD_VERBINCLUDE, CMD_VERSION, CMD_VHDLFLOW, CMD_WARNING, CMD_XMLINCLUDE, CMD_XMLONLY, CMD_XREFITEM, Mappers::cmdMapper, DocStyleChange::Code, Config_getBool, Config_getString, DocParser::context, DocParserContext::context, DocSimpleSect::Copyright, DocSimpleSect::Date, DocParser::defaultHandleTitleAndSize(), DocInclude::DocbookInclude, DocVerbatim::DocbookOnly, DocInclude::DontInclude, DocVerbatim::Dot, DocParserContext::exampleName, DocParamSect::Exception, FALSE, QCString::find(), found, g_plantumlEngine, DocNodeList::get_last(), Doxygen::globalScope, DocParser::handleAnchor(), handleCite(), handleDoxyConfig(), handleEmoji(), handleFile(), handleIFile(), handleILine(), DocParser::handleImage(), handleInclude(), handleIncludeOperator(), handleInheritDoc(), DocParser::handleInternalRef(), handleLink(), handleParamSection(), DocParser::handlePrefix(), 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, QCString::mid(), DocVerbatim::Msc, TokenInfo::name, DocParserContext::nodeStack, DocSimpleSect::Note, DocParamSect::Param, 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::setStateMsc(), DocTokenizer::setStatePara(), DocTokenizer::setStatePlantUML(), DocTokenizer::setStatePlantUMLOpt(), DocTokenizer::setStateRtfOnly(), DocTokenizer::setStateSetScope(), DocTokenizer::setStateVerbatim(), DocTokenizer::setStateXmlOnly(), DocSimpleSect::Since, DocIncOperator::Skip, DocIncOperator::SkipLine, DocInclude::Snippet, DocInclude::SnippetWithLines, split(), QCString::str(), stripLeadingAndTrailingEmptyLines(), QCString::stripWhiteSpace(), HtmlEntityMapper::Sym_Amp, HtmlEntityMapper::Sym_At, HtmlEntityMapper::Sym_BSlash, HtmlEntityMapper::Sym_Dollar, HtmlEntityMapper::Sym_Dot, HtmlEntityMapper::Sym_DoubleColon, HtmlEntityMapper::Sym_Equal, HtmlEntityMapper::Sym_Exclam, HtmlEntityMapper::Sym_Greater, HtmlEntityMapper::Sym_Hash, HtmlEntityMapper::Sym_Less, HtmlEntityMapper::Sym_Minus, HtmlEntityMapper::Sym_Percent, HtmlEntityMapper::Sym_Pipe, HtmlEntityMapper::Sym_Plus, HtmlEntityMapper::Sym_Quest, HtmlEntityMapper::Sym_Quot, DocParamSect::TemplateParam, DocNode::thisVariant(), Token::to_string(), DocParserContext::token, DocParser::tokenizer, TRUE, UNKNOWN, DocIncOperator::Until, DocSimpleSect::User, TokenInfo::verb, DocVerbatim::Verbatim, DocInclude::VerbInclude, DocSimpleSect::Version, QCString::view(), warn, warn_doc_error, DocSimpleSect::Warning, DocInclude::XmlInclude, and DocVerbatim::XmlOnly.

Referenced by parse().

◆ handleDoxyConfig()

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

Definition at line 3364 of file docnode.cpp.

3365{
3366 // get the argument of the cite command.
3367 Token tok=parser()->tokenizer.lex();
3368 if (!tok.is(TokenRetval::TK_WHITESPACE))
3369 {
3370 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3371 cmdChar,cmdName);
3372 return;
3373 }
3374 parser()->tokenizer.setStateDoxyConfig();
3375 tok=parser()->tokenizer.lex();
3376 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3377 {
3378 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3379 "argument of command '{:c}{}'",cmdChar,cmdName);
3380 return;
3381 }
3382 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3383 {
3384 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3385 tok.to_string(),cmdChar,cmdName);
3386 return;
3387 }
3388 ConfigOption * opt = ConfigImpl::instance()->get(parser()->context.token->name);
3389 if (opt)
3390 {
3391 QCString optionValue;
3392 switch (opt->kind())
3393 {
3394 case ConfigOption::O_Bool:
3395 optionValue = *(static_cast<ConfigBool*>(opt)->valueStringRef());
3396 break;
3397 case ConfigOption::O_String:
3398 optionValue = *(static_cast<ConfigString*>(opt)->valueRef());
3399 break;
3400 case ConfigOption::O_Enum:
3401 optionValue = *(static_cast<ConfigEnum*>(opt)->valueRef());
3402 break;
3403 case ConfigOption::O_Int:
3404 optionValue = *(static_cast<ConfigInt*>(opt)->valueStringRef());
3405 break;
3406 case ConfigOption::O_List:
3407 {
3408 StringVector *lst = static_cast<ConfigList*>(opt)->valueRef();
3409 optionValue="";
3410 if (!lst->empty())
3411 {
3412 std::string lstFormat = theTranslator->trWriteList(static_cast<int>(lst->size())).str();
3413 static const reg::Ex marker(R"(@(\d+))");
3414 reg::Iterator it(lstFormat,marker);
3415 reg::Iterator end;
3416 size_t index=0;
3417 // now replace all markers with the real text
3418 for ( ; it!=end ; ++it)
3419 {
3420 const auto &match = *it;
3421 size_t newIndex = match.position();
3422 size_t matchLen = match.length();
3423 optionValue += lstFormat.substr(index,newIndex-index);
3424 unsigned long entryIndex = std::stoul(match[1].str());
3425 if (entryIndex<(unsigned long)lst->size())
3426 {
3427 optionValue += lst->at(entryIndex);
3428 }
3429 index=newIndex+matchLen;
3430 }
3431 optionValue+=lstFormat.substr(index);
3432 }
3433 }
3434 break;
3435 case ConfigOption::O_Obsolete:
3436 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Obsolete setting for '{:c}{}': '{}'",
3437 cmdChar,cmdName,parser()->context.token->name);
3438 break;
3439 case ConfigOption::O_Disabled:
3440 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(),
3441 "Disabled setting (i.e. not supported in this doxygen executable) for '{:c}{}': '{}'",
3442 cmdChar,cmdName,parser()->context.token->name);
3443 break;
3444 case ConfigOption::O_Info:
3445 // nothing to show here
3446 break;
3447 }
3448 if (!optionValue.isEmpty())
3449 {
3450 children().append<DocWord>(parser(),thisVariant(),optionValue);
3451 }
3452 }
3453 else
3454 {
3455 warn(parser()->context.fileName,parser()->tokenizer.getLineNr(), "Unknown option for '{:c}{}': '{}'",
3456 cmdChar,cmdName,parser()->context.token->name);
3457 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
3458 }
3459 parser()->tokenizer.setStatePara();
3460}
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:2039
QCString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:578
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:759

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

Referenced by handleCommand().

◆ handleEmoji()

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

Definition at line 3333 of file docnode.cpp.

3334{
3335 AUTO_TRACE();
3336 // get the argument of the emoji command.
3337 Token tok=parser()->tokenizer.lex();
3338 if (!tok.is(TokenRetval::TK_WHITESPACE))
3339 {
3340 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3341 cmdChar,cmdName);
3342 return;
3343 }
3344 parser()->tokenizer.setStateEmoji();
3345 tok=parser()->tokenizer.lex();
3346 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3347 {
3348 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"no emoji name given or unexpected end of comment block while parsing the "
3349 "argument of command '{:c}{}'",cmdChar,cmdName);
3350 parser()->tokenizer.setStatePara();
3351 return;
3352 }
3353 else if (!tok.is(TokenRetval::TK_WORD))
3354 {
3355 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3356 tok.to_string(),cmdChar,cmdName);
3357 parser()->tokenizer.setStatePara();
3358 return;
3359 }
3360 children().append<DocEmoji>(parser(),thisVariant(),parser()->context.token->name);
3361 parser()->tokenizer.setStatePara();
3362}
DocTokenizer::setStateEmoji
void setStateEmoji()
Definition doctokenizer.l:2119

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

3652{
3653 AUTO_TRACE("cmdName={}",cmdName);
3654 QCString saveCmdName = cmdName;
3655 Token tok=parser()->tokenizer.lex();
3656 if (!tok.is(TokenRetval::TK_WHITESPACE))
3657 {
3658 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3659 saveCmdName);
3660 return;
3661 }
3662 parser()->tokenizer.setStateFile();
3663 tok=parser()->tokenizer.lex();
3664 parser()->tokenizer.setStatePara();
3665 if (!tok.is(TokenRetval::TK_WORD))
3666 {
3667 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3668 tok.to_string(),saveCmdName);
3669 return;
3670 }
3671 QCString name = parser()->context.token->name;
3672 children().append<T>(parser(),thisVariant(),name,
3673 parser()->context.context,
3674 parser()->context.fileName,
3675 parser()->tokenizer.getLineNr());
3676 auto df = children().get_last<T>();
3677 if (!df->parse())
3678 {
3679 children().pop_back();
3680 }
3681}
DocTokenizer::setStateFile
void setStateFile()
Definition doctokenizer.l:2003
DocTokenizer::getLineNr
int getLineNr(void)
Definition doctokenizer.l:2197
DocParserContext::fileName
QCString fileName
Definition docparser_p.h:70

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

5207{
5208 AUTO_TRACE("tagName={}",tagName);
5209 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
5210 Token retval = Token::make_RetVal_OK();
5211 switch (tagId)
5212 {
5213 case HtmlTagType::HTML_UL:
5214 if (!insideUL(thisVariant()))
5215 {
5216 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ul> tag without matching <ul>");
5217 }
5218 else
5219 {
5220 retval = Token::make_RetVal_EndList();
5221 }
5222 break;
5223 case HtmlTagType::HTML_OL:
5224 if (!insideOL(thisVariant()))
5225 {
5226 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </ol> tag without matching <ol>");
5227 }
5228 else
5229 {
5230 retval = Token::make_RetVal_EndList();
5231 }
5232 break;
5233 case HtmlTagType::HTML_LI:
5234 if (!insideLI(thisVariant()))
5235 {
5236 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </li> tag without matching <li>");
5237 }
5238 else
5239 {
5240 // ignore </li> tags
5241 }
5242 break;
5243 case HtmlTagType::HTML_DETAILS:
5244 if (!insideDetails(thisVariant()))
5245 {
5246 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </details> tag without matching <details>");
5247 }
5248 else
5249 {
5250 retval = Token::make_RetVal_EndHtmlDetails();
5251 }
5252 break;
5253 case HtmlTagType::HTML_BLOCKQUOTE:
5254 if (!insideBlockQuote(thisVariant()))
5255 {
5256 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"found </blockquote> tag without matching <blockquote>");
5257 }
5258 else
5259 {
5260 retval = Token::make_RetVal_EndBlockQuote();
5261 }
5262 break;
5263 case HtmlTagType::HTML_BOLD:
5264 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Bold,tagName);
5265 break;
5266 case HtmlTagType::HTML_S:
5267 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::S,"s");
5268 break;
5269 case HtmlTagType::HTML_STRIKE:
5270 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Strike,tagName);
5271 break;
5272 case HtmlTagType::HTML_DEL:
5273 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Del,tagName);
5274 break;
5275 case HtmlTagType::HTML_UNDERLINE:
5276 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Underline,tagName);
5277 break;
5278 case HtmlTagType::HTML_INS:
5279 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Ins,tagName);
5280 break;
5281 case HtmlTagType::HTML_CODE:
5282 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5283 break;
5284 case HtmlTagType::HTML_KBD:
5285 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Kbd,tagName);
5286 break;
5287 case HtmlTagType::HTML_TT:
5288 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Typewriter,tagName);
5289 break;
5290 case HtmlTagType::HTML_EMPHASIS:
5291 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Italic,tagName);
5292 break;
5293 case HtmlTagType::HTML_DIV:
5294 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
5295 break;
5296 case HtmlTagType::HTML_SPAN:
5297 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
5298 break;
5299 case HtmlTagType::HTML_SUB:
5300 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Subscript,tagName);
5301 break;
5302 case HtmlTagType::HTML_SUP:
5303 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Superscript,tagName);
5304 break;
5305 case HtmlTagType::HTML_CENTER:
5306 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Center,tagName);
5307 break;
5308 case HtmlTagType::HTML_SMALL:
5309 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Small,tagName);
5310 break;
5311 case HtmlTagType::HTML_CITE:
5312 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Cite,tagName);
5313 break;
5314 case HtmlTagType::HTML_PRE:
5315 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Preformatted,tagName);
5316 setInsidePreformatted(FALSE);
5317 parser()->tokenizer.setInsidePre(FALSE);
5318 break;
5319 case HtmlTagType::HTML_P:
5320 retval = Token::make_TK_NEWPARA();
5321 break;
5322 case HtmlTagType::HTML_DL:
5323 retval = Token::make_RetVal_EndDesc();
5324 break;
5325 case HtmlTagType::HTML_DT:
5326 // ignore </dt> tag
5327 break;
5328 case HtmlTagType::HTML_DD:
5329 // ignore </dd> tag
5330 break;
5331 case HtmlTagType::HTML_TABLE:
5332 retval = Token::make_RetVal_EndTable();
5333 break;
5334 case HtmlTagType::HTML_TR:
5335 // ignore </tr> tag
5336 break;
5337 case HtmlTagType::HTML_TD:
5338 // ignore </td> tag
5339 break;
5340 case HtmlTagType::HTML_TH:
5341 // ignore </th> tag
5342 break;
5343 case HtmlTagType::HTML_THEAD:
5344 case HtmlTagType::HTML_TBODY:
5345 case HtmlTagType::HTML_TFOOT:
5346 // for time being ignore </t....> tag
5347 break;
5348 case HtmlTagType::HTML_CAPTION:
5349 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </caption> found");
5350 break;
5351 case HtmlTagType::HTML_BR:
5352 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </br> tag found");
5353 break;
5354 case HtmlTagType::HTML_H1:
5355 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h1> found");
5356 break;
5357 case HtmlTagType::HTML_H2:
5358 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h2> found");
5359 break;
5360 case HtmlTagType::HTML_H3:
5361 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h3> found");
5362 break;
5363 case HtmlTagType::HTML_H4:
5364 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h4> found");
5365 break;
5366 case HtmlTagType::HTML_H5:
5367 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h5> found");
5368 break;
5369 case HtmlTagType::HTML_H6:
5370 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </h6> found");
5371 break;
5372 case HtmlTagType::HTML_IMG:
5373 break;
5374 case HtmlTagType::HTML_HR:
5375 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Illegal </hr> tag found");
5376 break;
5377 case HtmlTagType::HTML_A:
5378 //warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag </a> found");
5379 // ignore </a> tag (can be part of <a name=...></a>
5380 break;
5381
5382 case HtmlTagType::XML_TERM:
5383 break;
5384 case HtmlTagType::XML_SUMMARY:
5385 retval = Token::make_TK_NEWPARA();
5386 break;
5387 case HtmlTagType::XML_REMARKS:
5388 case HtmlTagType::XML_PARA:
5389 case HtmlTagType::XML_VALUE:
5390 case HtmlTagType::XML_EXAMPLE:
5391 case HtmlTagType::XML_PARAM:
5392 case HtmlTagType::XML_LIST:
5393 case HtmlTagType::XML_TYPEPARAM:
5394 case HtmlTagType::XML_RETURNS:
5395 case HtmlTagType::XML_SEE:
5396 case HtmlTagType::XML_SEEALSO:
5397 case HtmlTagType::XML_EXCEPTION:
5398 case HtmlTagType::XML_INHERITDOC:
5399 retval = Token::make_RetVal_CloseXml();
5400 break;
5401 case HtmlTagType::XML_C:
5402 parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Code,tagName);
5403 break;
5404 case HtmlTagType::XML_ITEM:
5405 case HtmlTagType::XML_LISTHEADER:
5406 case HtmlTagType::XML_INCLUDE:
5407 case HtmlTagType::XML_PERMISSION:
5408 case HtmlTagType::XML_DESCRIPTION:
5409 case HtmlTagType::XML_PARAMREF:
5410 case HtmlTagType::XML_TYPEPARAMREF:
5411 // These tags are defined in .Net but are currently unsupported
5412 break;
5413 case HtmlTagType::UNKNOWN:
5414 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag </{}> found", tagName);
5415 children().append<DocWord>(parser(),thisVariant(),"</"+tagName+">");
5416 break;
5417 default:
5418 // we should not get here!
5419 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected end tag {}",tagName);
5420 ASSERT(0);
5421 break;
5422 }
5423 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5424 return retval;
5425}
DocNode::setInsidePreformatted
void setInsidePreformatted(bool p)
Definition docnode.h:108
DocParser::handleStyleLeave
void handleStyleLeave(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const QCString &tagName)
Definition docparser.cpp:634
DocTokenizer::setInsidePre
void setInsidePre(bool b)
Definition doctokenizer.l:2155
HtmlTagType
HtmlTagType
Definition cmdmapper.h:169
insideUL
bool insideUL(const DocNodeVariant *n)
Definition docparser_p.h:213
insideLI
bool insideLI(const DocNodeVariant *n)
Definition docparser_p.h:188
insideBlockQuote
bool insideBlockQuote(const DocNodeVariant *n)
Definition docparser_p.h:199
insideDetails
bool insideDetails(const DocNodeVariant *n)
Definition docparser_p.h:258
insideOL
bool insideOL(const DocNodeVariant *n)
Definition docparser_p.h:230
Mappers::htmlTagMapper
const Mapper< HtmlTagType > * htmlTagMapper
Definition cmdmapper.cpp:251
ASSERT
#define ASSERT(x)
Definition qcstring.h:39

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

Referenced by parse().

◆ handleHtmlHeader()

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

Definition at line 3894 of file docnode.cpp.

3895{
3896 AUTO_TRACE();
3897 children().append<DocHtmlHeader>(parser(),thisVariant(),tagHtmlAttribs,level);
3898 Token retval = children().get_last<DocHtmlHeader>()->parse();
3899 return retval.is(TokenRetval::RetVal_OK) ? Token::make_TK_NEWPARA() : retval;
3900}

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

4736{
4737 AUTO_TRACE("tagName={} #tagHtmlAttrs={}",tagName,tagHtmlAttribs.size());
4738 Token retval = Token::make_RetVal_OK();
4739 HtmlTagType tagId = Mappers::htmlTagMapper->map(tagName);
4740 if (parser()->context.token->emptyTag && !(tagId>HtmlTagType::XML_CmdMask) &&
4741 tagId!=HtmlTagType::UNKNOWN && tagId!=HtmlTagType::HTML_IMG && tagId!=HtmlTagType::HTML_BR && tagId!=HtmlTagType::HTML_HR && tagId!=HtmlTagType::HTML_P
4742 && tagId!=HtmlTagType::HTML_DIV && tagId!=HtmlTagType::HTML_SPAN)
4743 {
4744 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"HTML tag ('<{}/>') may not use the 'empty tag' XHTML syntax.",
4745 tagName);
4746 }
4747 switch (tagId)
4748 {
4749 case HtmlTagType::HTML_UL:
4750 if (!parser()->context.token->emptyTag)
4751 {
4752 children().append<DocHtmlList>(parser(),thisVariant(),
4753 tagHtmlAttribs,DocHtmlList::Unordered);
4754 retval=children().get_last<DocHtmlList>()->parse();
4755 }
4756 break;
4757 case HtmlTagType::HTML_OL:
4758 if (!parser()->context.token->emptyTag)
4759 {
4760 children().append<DocHtmlList>(parser(),thisVariant(),
4761 tagHtmlAttribs,DocHtmlList::Ordered);
4762 retval=children().get_last<DocHtmlList>()->parse();
4763 }
4764 break;
4765 case HtmlTagType::HTML_LI:
4766 if (parser()->context.token->emptyTag) break;
4767 if (!insideUL(thisVariant()) && !insideOL(thisVariant()))
4768 {
4769 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <li> tag found");
4770 }
4771 else
4772 {
4773 retval = Token::make_RetVal_ListItem();
4774 }
4775 break;
4776 case HtmlTagType::HTML_BOLD:
4777 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Bold,tagName,&parser()->context.token->attribs);
4778 break;
4779 case HtmlTagType::HTML_S:
4780 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::S,tagName,&parser()->context.token->attribs);
4781 break;
4782 case HtmlTagType::HTML_STRIKE:
4783 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Strike,tagName,&parser()->context.token->attribs);
4784 break;
4785 case HtmlTagType::HTML_DEL:
4786 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Del,tagName,&parser()->context.token->attribs);
4787 break;
4788 case HtmlTagType::HTML_UNDERLINE:
4789 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Underline,tagName,&parser()->context.token->attribs);
4790 break;
4791 case HtmlTagType::HTML_INS:
4792 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Ins,tagName,&parser()->context.token->attribs);
4793 break;
4794 case HtmlTagType::HTML_CODE:
4795 if (parser()->context.token->emptyTag) break;
4796 if (parser()->context.xmlComment)
4797 // for C# source or inside a <summary> or <remark> section we
4798 // treat <code> as an XML tag (so similar to @code)
4799 {
4800 parser()->tokenizer.setStateXmlCode();
4801 retval = handleStartCode();
4802 }
4803 else // normal HTML markup
4804 {
4805 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
4806 }
4807 break;
4808 case HtmlTagType::HTML_KBD:
4809 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Kbd,tagName,&parser()->context.token->attribs);
4810 break;
4811 case HtmlTagType::HTML_TT:
4812 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Typewriter,tagName,&parser()->context.token->attribs);
4813 break;
4814 case HtmlTagType::HTML_EMPHASIS:
4815 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Italic,tagName,&parser()->context.token->attribs);
4816 break;
4817 case HtmlTagType::HTML_DIV:
4818 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Div,tagName,&parser()->context.token->attribs);
4819 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Div,tagName);
4820 break;
4821 case HtmlTagType::HTML_SPAN:
4822 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Span,tagName,&parser()->context.token->attribs);
4823 if (parser()->context.token->emptyTag) parser()->handleStyleLeave(thisVariant(),children(),DocStyleChange::Span,tagName);
4824 break;
4825 case HtmlTagType::HTML_SUB:
4826 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Subscript,tagName,&parser()->context.token->attribs);
4827 break;
4828 case HtmlTagType::HTML_SUP:
4829 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Superscript,tagName,&parser()->context.token->attribs);
4830 break;
4831 case HtmlTagType::HTML_CENTER:
4832 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Center,tagName,&parser()->context.token->attribs);
4833 break;
4834 case HtmlTagType::HTML_SMALL:
4835 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Small,tagName,&parser()->context.token->attribs);
4836 break;
4837 case HtmlTagType::HTML_CITE:
4838 if (!parser()->context.token->emptyTag) parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Cite,tagName,&parser()->context.token->attribs);
4839 break;
4840 case HtmlTagType::HTML_PRE:
4841 if (parser()->context.token->emptyTag) break;
4842 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Preformatted,tagName,&parser()->context.token->attribs);
4843 setInsidePreformatted(TRUE);
4844 parser()->tokenizer.setInsidePre(TRUE);
4845 break;
4846 case HtmlTagType::HTML_P:
4847 retval = Token::make_TK_NEWPARA();
4848 break;
4849 case HtmlTagType::HTML_DL:
4850 if (!parser()->context.token->emptyTag)
4851 {
4852 children().append<DocHtmlDescList>(parser(),thisVariant(),tagHtmlAttribs);
4853 retval=children().get_last<DocHtmlDescList>()->parse();
4854 }
4855 break;
4856 case HtmlTagType::HTML_DT:
4857 if (insideDL(thisVariant()))
4858 {
4859 retval = Token::make_RetVal_DescTitle();
4860 }
4861 else
4862 {
4863 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dt> found");
4864 }
4865 break;
4866 case HtmlTagType::HTML_DD:
4867 if (insideDL(thisVariant()))
4868 {
4869 retval = Token::make_RetVal_DescData();
4870 }
4871 else
4872 {
4873 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <dd> found");
4874 }
4875 break;
4876 case HtmlTagType::HTML_TABLE:
4877 if (!parser()->context.token->emptyTag)
4878 {
4879 children().append<DocHtmlTable>(parser(),thisVariant(),tagHtmlAttribs);
4880 retval=children().get_last<DocHtmlTable>()->parse();
4881 }
4882 break;
4883 case HtmlTagType::HTML_TR:
4884 retval = Token::make_RetVal_TableRow();
4885 break;
4886 case HtmlTagType::HTML_TD:
4887 retval = Token::make_RetVal_TableCell();
4888 break;
4889 case HtmlTagType::HTML_TH:
4890 retval = Token::make_RetVal_TableHCell();
4891 break;
4892 case HtmlTagType::HTML_THEAD:
4893 case HtmlTagType::HTML_TBODY:
4894 case HtmlTagType::HTML_TFOOT:
4895 // for time being ignore </t....> tag
4896 break;
4897 case HtmlTagType::HTML_CAPTION:
4898 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected tag <caption> found");
4899 break;
4900 case HtmlTagType::HTML_BR:
4901 {
4902 children().append<DocLineBreak>(parser(),thisVariant(),tagHtmlAttribs);
4903 }
4904 break;
4905 case HtmlTagType::HTML_HR:
4906 {
4907 children().append<DocHorRuler>(parser(),thisVariant(),tagHtmlAttribs);
4908 }
4909 break;
4910 case HtmlTagType::HTML_A:
4911 retval = parser()->handleAHref(thisVariant(),children(),tagHtmlAttribs);
4912 break;
4913 case HtmlTagType::HTML_H1:
4914 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,1);
4915 break;
4916 case HtmlTagType::HTML_H2:
4917 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,2);
4918 break;
4919 case HtmlTagType::HTML_H3:
4920 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,3);
4921 break;
4922 case HtmlTagType::HTML_H4:
4923 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,4);
4924 break;
4925 case HtmlTagType::HTML_H5:
4926 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,5);
4927 break;
4928 case HtmlTagType::HTML_H6:
4929 if (!parser()->context.token->emptyTag) retval=handleHtmlHeader(tagHtmlAttribs,6);
4930 break;
4931 case HtmlTagType::HTML_IMG:
4932 {
4933 parser()->handleImg(thisVariant(),children(),tagHtmlAttribs);
4934 }
4935 break;
4936 case HtmlTagType::HTML_DETAILS:
4937 if (!parser()->context.token->emptyTag)
4938 {
4939 children().append<DocHtmlDetails>(parser(),thisVariant(),tagHtmlAttribs);
4940 retval=children().get_last<DocHtmlDetails>()->parse();
4941 }
4942 break;
4943 case HtmlTagType::HTML_BLOCKQUOTE:
4944 if (!parser()->context.token->emptyTag)
4945 {
4946 children().append<DocHtmlBlockQuote>(parser(),thisVariant(),tagHtmlAttribs);
4947 retval = children().get_last<DocHtmlBlockQuote>()->parse();
4948 }
4949 break;
4950
4951 case HtmlTagType::XML_SUMMARY:
4952 if (insideDetails(thisVariant()))
4953 {
4954 if (!parser()->context.token->emptyTag)
4955 {
4956 DocNodeVariant *n=parent();
4957 while (n && !std::holds_alternative<DocHtmlDetails>(*n)) n=::parent(n);
4958 DocHtmlDetails *d = std::get_if<DocHtmlDetails>(n);
4959 if (d)
4960 {
4961 if (!d->summary()) // details section does not have a summary yet
4962 {
4963 d->parseSummary(n,parser()->context.token->attribs);
4964 }
4965 else
4966 {
4967 retval = Token::make_TK_NEWPARA();
4968 }
4969 }
4970 }
4971 }
4972 break;
4973 case HtmlTagType::XML_REMARKS:
4974 case HtmlTagType::XML_EXAMPLE:
4975 parser()->context.xmlComment=TRUE;
4976 // fall through
4977 case HtmlTagType::XML_VALUE:
4978 case HtmlTagType::XML_PARA:
4979 if (!children().empty())
4980 {
4981 retval = Token::make_TK_NEWPARA();
4982 }
4983 break;
4984 case HtmlTagType::XML_DESCRIPTION:
4985 if (insideTable(thisVariant()))
4986 {
4987 retval = Token::make_RetVal_TableCell();
4988 }
4989 break;
4990 case HtmlTagType::XML_C:
4991 parser()->handleStyleEnter(thisVariant(),children(),DocStyleChange::Code,tagName,&parser()->context.token->attribs);
4992 break;
4993 case HtmlTagType::XML_PARAM:
4994 case HtmlTagType::XML_TYPEPARAM:
4995 {
4996 parser()->context.xmlComment=TRUE;
4997 QCString paramName;
4998 if (findAttribute(tagHtmlAttribs,"name",&paramName))
4999 {
5000 if (paramName.isEmpty())
5001 {
5002 if (Config_getBool(WARN_NO_PARAMDOC))
5003 {
5004 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"empty 'name' attribute for <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5005 }
5006 }
5007 else
5008 {
5009 retval = handleParamSection(paramName,
5010 tagId==HtmlTagType::XML_PARAM ? DocParamSect::Param : DocParamSect::TemplateParam,
5011 TRUE);
5012 }
5013 }
5014 else
5015 {
5016 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}> tag.",tagId==HtmlTagType::XML_PARAM?"":"type");
5017 }
5018 }
5019 break;
5020 case HtmlTagType::XML_PARAMREF:
5021 case HtmlTagType::XML_TYPEPARAMREF:
5022 {
5023 QCString paramName;
5024 if (findAttribute(tagHtmlAttribs,"name",&paramName))
5025 {
5026 //printf("paramName=%s\n",qPrint(paramName));
5027 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,TRUE);
5028 children().append<DocWord>(parser(),thisVariant(),paramName);
5029 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Italic,tagName,FALSE);
5030 if (!retval.is(TokenRetval::TK_WORD)) children().append<DocWhiteSpace>(parser(),thisVariant()," ");
5031 }
5032 else
5033 {
5034 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'name' attribute from <param{}ref> tag.",tagId==HtmlTagType::XML_PARAMREF?"":"type");
5035 }
5036 }
5037 break;
5038 case HtmlTagType::XML_EXCEPTION:
5039 {
5040 parser()->context.xmlComment=TRUE;
5041 QCString exceptName;
5042 if (findAttribute(tagHtmlAttribs,"cref",&exceptName))
5043 {
5044 unescapeCRef(exceptName);
5045 retval = handleParamSection(exceptName,DocParamSect::Exception,TRUE);
5046 }
5047 else
5048 {
5049 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <exception> tag.");
5050 }
5051 }
5052 break;
5053 case HtmlTagType::XML_ITEM:
5054 case HtmlTagType::XML_LISTHEADER:
5055 if (insideTable(thisVariant()))
5056 {
5057 retval = Token::make_RetVal_TableRow();
5058 }
5059 else if (insideUL(thisVariant()) || insideOL(thisVariant()))
5060 {
5061 retval = Token::make_RetVal_ListItem();
5062 }
5063 else
5064 {
5065 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"lonely <item> tag found");
5066 }
5067 break;
5068 case HtmlTagType::XML_RETURNS:
5069 parser()->context.xmlComment=TRUE;
5070 retval = handleSimpleSection(DocSimpleSect::Return,TRUE);
5071 parser()->context.hasReturnCommand=TRUE;
5072 break;
5073 case HtmlTagType::XML_TERM:
5074 if (insideTable(thisVariant()))
5075 {
5076 retval = Token::make_RetVal_TableCell();
5077 }
5078 break;
5079 case HtmlTagType::XML_SEE:
5080 // I'm not sure if <see> is the same as <seealso> or if it
5081 // should you link a member without producing a section. The
5082 // C# specification is extremely vague about this (but what else
5083 // can we expect from Microsoft...)
5084 {
5085 QCString cref;
5086 //printf("HtmlTagType::XML_SEE: empty tag=%d\n",parser()->context.token->emptyTag);
5087 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5088 {
5089 unescapeCRef(cref);
5090 if (parser()->context.token->emptyTag) // <see cref="..."/> style
5091 {
5092 bool inSeeBlock = parser()->context.inSeeBlock;
5093 parser()->context.token->name = cref;
5094 parser()->context.inSeeBlock = TRUE;
5095 parser()->handleLinkedWord(thisVariant(),children(),TRUE);
5096 parser()->context.inSeeBlock = inSeeBlock;
5097 }
5098 else // <see cref="...">...</see> style
5099 {
5100 //DocRef *ref = new DocRef(this,cref);
5101 //children().append(ref);
5102 //ref->parse();
5103 parser()->tokenizer.setStatePara();
5104 children().append<DocLink>(parser(),thisVariant(),cref);
5105 DocLink *lnk = children().get_last<DocLink>();
5106 QCString leftOver = lnk->parse(FALSE,TRUE);
5107 if (!leftOver.isEmpty())
5108 {
5109 children().append<DocWord>(parser(),thisVariant(),leftOver);
5110 }
5111 }
5112 }
5113 else if (findAttribute(tagHtmlAttribs,"langword",&cref)) // <see langword="..."/> or <see langword="..."></see>
5114 {
5115 bool inSeeBlock = parser()->context.inSeeBlock;
5116 parser()->context.token->name = cref;
5117 parser()->context.inSeeBlock = TRUE;
5118 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,TRUE);
5119 parser()->handleLinkedWord(thisVariant(),children(),TRUE);
5120 children().append<DocStyleChange>(parser(),thisVariant(),parser()->context.nodeStack.size(),DocStyleChange::Code,tagName,FALSE);
5121 parser()->context.inSeeBlock = inSeeBlock;
5122 }
5123 else
5124 {
5125 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' or 'langword' attribute from <see> tag.");
5126 }
5127 }
5128 break;
5129 case HtmlTagType::XML_SEEALSO:
5130 {
5131 parser()->context.xmlComment=TRUE;
5132 QCString cref;
5133 if (findAttribute(tagHtmlAttribs,"cref",&cref))
5134 {
5135 unescapeCRef(cref);
5136 // Look for an existing "see" section
5137 DocNodeVariant *vss=nullptr;
5138 for (auto &n : children())
5139 {
5140 DocSimpleSect *candidate = std::get_if<DocSimpleSect>(&n);
5141 if (candidate && candidate->type()==DocSimpleSect::See)
5142 {
5143 vss = &n;
5144 }
5145 }
5146
5147 if (!vss) // start new section
5148 {
5149 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::See);
5150 vss = &children().back();
5151 }
5152
5153 std::get<DocSimpleSect>(*vss).appendLinkWord(cref);
5154 retval = Token::make_RetVal_OK();
5155 }
5156 else
5157 {
5158 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Missing 'cref' attribute from <seealso> tag.");
5159 }
5160 }
5161 break;
5162 case HtmlTagType::XML_LIST:
5163 {
5164 QCString type;
5165 findAttribute(tagHtmlAttribs,"type",&type);
5166 DocHtmlList::Type listType = DocHtmlList::Unordered;
5167 HtmlAttribList emptyList;
5168 if (type=="number")
5169 {
5170 listType=DocHtmlList::Ordered;
5171 }
5172 if (type=="table")
5173 {
5174 children().append<DocHtmlTable>(parser(),thisVariant(),emptyList);
5175 retval=children().get_last<DocHtmlTable>()->parseXml();
5176 }
5177 else
5178 {
5179 children().append<DocHtmlList>(parser(),thisVariant(),emptyList,listType);
5180 retval=children().get_last<DocHtmlList>()->parseXml();
5181 }
5182 }
5183 break;
5184 case HtmlTagType::XML_INCLUDE:
5185 case HtmlTagType::XML_PERMISSION:
5186 // These tags are defined in .Net but are currently unsupported
5187 parser()->context.xmlComment=TRUE;
5188 break;
5189 case HtmlTagType::UNKNOWN:
5190 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported xml/html tag <{}> found", tagName);
5191 children().append<DocWord>(parser(),thisVariant(), "<"+tagName+parser()->context.token->attribsStr+">");
5192 break;
5193 case HtmlTagType::XML_INHERITDOC:
5194 handleInheritDoc();
5195 break;
5196 default:
5197 // we should not get here!
5198 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unexpected start tag {}",tagName);
5199 ASSERT(0);
5200 break;
5201 }
5202 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5203 return retval;
5204}
DocHtmlDetails::parseSummary
void parseSummary(DocNodeVariant *, HtmlAttribList &attribs)
Definition docnode.cpp:1455
DocHtmlDetails::summary
const DocNodeVariant * summary() const
Definition docnode.h:859
DocPara::handleHtmlHeader
Token handleHtmlHeader(const HtmlAttribList &tagHtmlAttribs, int level)
Definition docnode.cpp:3894
DocParser::handleLinkedWord
void handleLinkedWord(DocNodeVariant *parent, DocNodeList &children, bool ignoreAutoLinkFlag=FALSE)
Definition docparser.cpp:777
DocParser::handleAHref
Token handleAHref(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:708
DocParser::handleStyleEnter
void handleStyleEnter(DocNodeVariant *parent, DocNodeList &children, DocStyleChange::Style s, const QCString &tagName, const HtmlAttribList *attribs)
Definition docparser.cpp:622
DocParser::handleImg
void handleImg(DocNodeVariant *parent, DocNodeList &children, const HtmlAttribList &tagHtmlAttribs)
Definition docparser.cpp:1584
DocSimpleSect::type
Type type() const
Definition docnode.h:1021
DocTokenizer::setStateXmlCode
void setStateXmlCode()
Definition doctokenizer.l:1866
GrowVector::back
T & back()
access the last element
Definition growvector.h:135
unescapeCRef
static void unescapeCRef(QCString &s)
Definition docnode.cpp:81
findAttribute
static bool findAttribute(const HtmlAttribList &tagHtmlAttribs, const char *attrName, QCString *result)
Definition docnode.cpp:4719
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 > DocNodeVariant
Definition docnode.h:66
insideTable
bool insideTable(const DocNodeVariant *n)
Definition docparser_p.h:246
insideDL
bool insideDL(const DocNodeVariant *n)
Definition docparser_p.h:270
TokenInfo::attribsStr
QCString attribsStr
Definition doctokenizer.h:165

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

Referenced by parse().

◆ handleIFile()

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

Definition at line 3567 of file docnode.cpp.

3568{
3569 AUTO_TRACE();
3570 Token tok=parser()->tokenizer.lex();
3571 if (!tok.is(TokenRetval::TK_WHITESPACE))
3572 {
3573 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3574 cmdChar,cmdName);
3575 return;
3576 }
3577 parser()->tokenizer.setStateFile();
3578 tok=parser()->tokenizer.lex();
3579 parser()->tokenizer.setStatePara();
3580 if (!tok.is(TokenRetval::TK_WORD))
3581 {
3582 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3583 tok.to_string(),cmdChar,cmdName);
3584 return;
3585 }
3586 parser()->context.fileName = parser()->context.token->name;
3587 parser()->tokenizer.setStatePara();
3588}

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

Referenced by handleCommand().

◆ handleILine()

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

Definition at line 3553 of file docnode.cpp.

3554{
3555 AUTO_TRACE();
3556 parser()->tokenizer.setStateILine();
3557 Token tok = parser()->tokenizer.lex();
3558 if (!tok.is(TokenRetval::TK_WORD))
3559 {
3560 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid argument for command '{:c}{}'",
3561 cmdChar,cmdName);
3562 return;
3563 }
3564 parser()->tokenizer.setStatePara();
3565}
DocTokenizer::setStateILine
void setStateILine()
Definition doctokenizer.l:2127

References AUTO_TRACE, Token::is(), DocTokenizer::lex(), DocNode::parser(), DocTokenizer::setStateILine(), DocTokenizer::setStatePara(), DocParser::tokenizer, and warn_doc_error.

Referenced by handleCommand().

◆ handleInclude()

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

Definition at line 3758 of file docnode.cpp.

3759{
3760 AUTO_TRACE("cmdName={}",cmdName);
3761 QCString saveCmdName = cmdName;
3762 Token tok=parser()->tokenizer.lex();
3763 bool isBlock = false;
3764 bool trimLeft = false;
3765 bool localScope = false;
3766 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3767 if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="{")
3768 {
3769 parser()->tokenizer.setStateOptions();
3770 parser()->tokenizer.lex();
3771 parser()->tokenizer.setStatePara();
3772 StringVector optList=split(parser()->context.token->name.str(),",");
3773 auto contains = [&optList](const char *kw)
3774 {
3775 return std::find(optList.begin(),optList.end(),kw)!=optList.end();
3776 };
3777 localScope = contains("local");
3778 if (contains("nostrip"))
3779 {
3780 stripCodeComments = false;
3781 }
3782 else if (contains("strip"))
3783 {
3784 stripCodeComments = true;
3785 }
3786 if (t==DocInclude::Snippet && contains("trimleft"))
3787 {
3788 trimLeft = true;
3789 }
3790
3791 if (contains("lineno"))
3792 {
3793 if (t==DocInclude::Include) t = DocInclude::IncWithLines;
3794 else if (t==DocInclude::Snippet) t = DocInclude::SnippetWithLines;
3795 else if (t==DocInclude::DontInclude) t = DocInclude::DontIncWithLines;
3796 }
3797 tok=parser()->tokenizer.lex();
3798 if (!tok.is(TokenRetval::TK_WHITESPACE))
3799 {
3800 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3801 saveCmdName);
3802 return;
3803 }
3804 }
3805 else if (tok.is(TokenRetval::TK_WORD) && parser()->context.token->name=="[")
3806 {
3807 parser()->tokenizer.setStateBlock();
3808 parser()->tokenizer.lex();
3809 isBlock = (parser()->context.token->name.stripWhiteSpace() == "block");
3810 parser()->tokenizer.setStatePara();
3811 parser()->tokenizer.lex();
3812 }
3813 else if (!tok.is(TokenRetval::TK_WHITESPACE))
3814 {
3815 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3816 saveCmdName);
3817 return;
3818 }
3819 parser()->tokenizer.setStateFile();
3820 tok=parser()->tokenizer.lex();
3821 parser()->tokenizer.setStatePara();
3822 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3823 {
3824 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3825 "argument of command {}",saveCmdName);
3826 return;
3827 }
3828 else if (!tok.is(TokenRetval::TK_WORD))
3829 {
3830 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3831 tok.to_string(),saveCmdName);
3832 return;
3833 }
3834 QCString fileName = parser()->context.token->name;
3835 QCString blockId;
3836 if (t==DocInclude::Snippet || t==DocInclude::SnippetWithLines)
3837 {
3838 if (fileName == "this") fileName=parser()->context.fileName;
3839 parser()->tokenizer.setStateSnippet();
3840 tok=parser()->tokenizer.lex();
3841 parser()->tokenizer.setStatePara();
3842 if (!tok.is(TokenRetval::TK_WORD))
3843 {
3844 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected block identifier, but found token {} instead while parsing the {} command",
3845 tok.to_string(),saveCmdName);
3846 return;
3847 }
3848 blockId = "["+parser()->context.token->name+"]";
3849 }
3850
3851 children().append<DocInclude>(parser(),
3852 thisVariant(),
3853 fileName,
3854 localScope ? parser()->context.context : "",
3855 t,
3856 stripCodeComments,
3857 parser()->context.isExample,
3858 parser()->context.exampleName,
3859 blockId,isBlock,trimLeft);
3860 children().get_last<DocInclude>()->parse();
3861}
DocInclude::DontIncWithLines
@ DontIncWithLines
Definition docnode.h:435
DocTokenizer::setStateSnippet
void setStateSnippet()
Definition doctokenizer.l:2088
DocTokenizer::setStateBlock
void setStateBlock()
Definition doctokenizer.l:2111
DocTokenizer::setStateOptions
void setStateOptions()
Definition doctokenizer.l:2103

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

3592{
3593 AUTO_TRACE("cmdName={}",cmdName);
3594 QCString saveCmdName = cmdName;
3595 Token tok=parser()->tokenizer.lex();
3596 if (!tok.is(TokenRetval::TK_WHITESPACE))
3597 {
3598 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3599 saveCmdName);
3600 return;
3601 }
3602 parser()->tokenizer.setStatePattern();
3603 tok=parser()->tokenizer.lex();
3604 parser()->tokenizer.setStatePara();
3605 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3606 {
3607 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3608 "argument of command {}", saveCmdName);
3609 return;
3610 }
3611 else if (!tok.is(TokenRetval::TK_WORD))
3612 {
3613 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of {}",
3614 tok.to_string(),saveCmdName);
3615 return;
3616 }
3617 auto it1 = children().size()>=1 ? std::prev(children().end()) : children().end();
3618 auto it2 = children().size()>=2 ? std::prev(it1) : children().end();
3619 DocNodeVariant *n1 = it1!=children().end() ? &(*it1) : nullptr;
3620 DocNodeVariant *n2 = it2!=children().end() ? &(*it2) : nullptr;
3621 //TODO get from context the stripCodeComments()
3622 bool stripCodeComments = Config_getBool(STRIP_CODE_COMMENTS);
3623 children().append<DocIncOperator>(parser(),thisVariant(),t,
3624 parser()->context.token->name,
3625 parser()->context.context,
3626 stripCodeComments,
3627 parser()->context.isExample,
3628 parser()->context.exampleName
3629 );
3630 DocIncOperator *op = children().get_last<DocIncOperator>();
3631 DocIncOperator *n1_docIncOp = std::get_if<DocIncOperator>(n1);
3632 DocWhiteSpace *n1_docWs = std::get_if<DocWhiteSpace >(n1);
3633 DocIncOperator *n2_docIncOp = std::get_if<DocIncOperator>(n2);
3634 bool isFirst = !n1 || // no last node
3635 (!n1_docIncOp && !n1_docWs) || // last node is not operator or whitespace
3636 (n1_docWs && n2 && !n2_docIncOp); // last node is not operator
3637 op->markFirst(isFirst);
3638 op->markLast(true);
3639 if (n1_docIncOp)
3640 {
3641 n1_docIncOp->markLast(false);
3642 }
3643 else if (n1_docWs && n2_docIncOp)
3644 {
3645 n2_docIncOp->markLast(false);
3646 }
3647 op->parse();
3648}
DocIncOperator::markLast
void markLast(bool v=TRUE)
Definition docnode.h:501
DocPara::isFirst
bool isFirst() const
Definition docnode.h:1082
DocTokenizer::setStatePattern
void setStatePattern()
Definition doctokenizer.l:2017
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 3948 of file docnode.cpp.

3949{
3950 if (parser()->context.memberDef) // inheriting docs from a member
3951 {
3952 const MemberDef *reMd = parser()->context.memberDef->reimplements();
3953 if (reMd) // member from which was inherited.
3954 {
3955 const MemberDef *thisMd = parser()->context.memberDef;
3956 //printf("{InheritDocs:%s=>%s}\n",qPrint(parser()->context.memberDef->qualifiedName()),qPrint(reMd->qualifiedName()));
3957 parser()->pushContext();
3958 parser()->context.scope=reMd->getOuterScope();
3959 if (parser()->context.scope!=Doxygen::globalScope)
3960 {
3961 parser()->context.context=parser()->context.scope->name();
3962 }
3963 parser()->context.memberDef=reMd;
3964 while (!parser()->context.styleStack.empty()) parser()->context.styleStack.pop();
3965 while (!parser()->context.nodeStack.empty()) parser()->context.nodeStack.pop();
3966 parser()->context.copyStack.push_back(reMd);
3967 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->briefDescription());
3968 parser()->internalValidatingParseDoc(thisVariant(),children(),reMd->documentation());
3969 parser()->context.copyStack.pop_back();
3970 auto hasParamCommand = parser()->context.hasParamCommand;
3971 auto hasReturnCommand = parser()->context.hasReturnCommand;
3972 auto retvalsFound = parser()->context.retvalsFound;
3973 auto paramsFound = parser()->context.paramsFound;
3974 parser()->popContext();
3975 parser()->context.hasParamCommand = hasParamCommand;
3976 parser()->context.hasReturnCommand = hasReturnCommand;
3977 parser()->context.retvalsFound = retvalsFound;
3978 parser()->context.paramsFound = paramsFound;
3979 parser()->context.memberDef = thisMd;
3980 }
3981 }
3982}
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:1615
DocParser::popContext
void popContext()
Definition docparser.cpp:74
DocParser::pushContext
void pushContext()
Definition docparser.cpp:60
MemberDef::reimplements
virtual const MemberDef * reimplements() const =0
DocParserContext::retvalsFound
StringMultiSet retvalsFound
Definition docparser_p.h:75
DocParserContext::styleStack
DocStyleChangeStack styleStack
Definition docparser_p.h:67
DocParserContext::paramsFound
StringMultiSet paramsFound
Definition docparser_p.h:76
DocParserContext::copyStack
DefinitionStack copyStack
Definition docparser_p.h:69

References Definition::briefDescription(), DocCompoundNode::children(), DocParser::context, DocParserContext::context, DocParserContext::copyStack, Definition::documentation(), Definition::getOuterScope(), Doxygen::globalScope, DocParserContext::hasParamCommand, DocParserContext::hasReturnCommand, DocParser::internalValidatingParseDoc(), DocParserContext::memberDef, Definition::name(), DocParserContext::nodeStack, DocParserContext::paramsFound, DocNode::parser(), DocParser::popContext(), DocParser::pushContext(), 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 3690 of file docnode.cpp.

3691{
3692 AUTO_TRACE("cmdName={} isJavaLink={}",cmdName,isJavaLink);
3693 QCString saveCmdName = cmdName;
3694 Token tok=parser()->tokenizer.lex();
3695 if (!tok.is(TokenRetval::TK_WHITESPACE))
3696 {
3697 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after \\{} command",
3698 saveCmdName);
3699 return;
3700 }
3701 parser()->tokenizer.setStateLink();
3702 tok=parser()->tokenizer.lex();
3703 if (!tok.is(TokenRetval::TK_WORD))
3704 {
3705 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"{} as the argument of {}",
3706 tok.to_string(),saveCmdName);
3707 return;
3708 }
3709 if (saveCmdName == "javalink")
3710 {
3711 children().append<DocStyleChange>(parser(),thisVariant(),
3712 parser()->context.nodeStack.size(),
3713 DocStyleChange::Code,cmdName,TRUE);
3714 }
3715 parser()->tokenizer.setStatePara();
3716 children().append<DocLink>(parser(),thisVariant(),parser()->context.token->name);
3717 DocLink *lnk = children().get_last<DocLink>();
3718 if (saveCmdName == "javalink")
3719 {
3720 children().append<DocStyleChange>(parser(),thisVariant(),
3721 parser()->context.nodeStack.size(),
3722 DocStyleChange::Code,cmdName,FALSE);
3723 }
3724 QCString leftOver = lnk->parse(isJavaLink);
3725 if (!leftOver.isEmpty())
3726 {
3727 children().append<DocWord>(parser(),thisVariant(),leftOver);
3728 }
3729}
DocTokenizer::setStateLink
void setStateLink()
Definition doctokenizer.l:2025

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

Referenced by handleCommand().

◆ handleParamSection()

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

Definition at line 3278 of file docnode.cpp.

3282{
3283 AUTO_TRACE();
3284 DocParamSect *ps = nullptr;
3285 if (!children().empty() && // previous element
3286 (ps=children().get_last<DocParamSect>()) && // was a param sect
3287 ps->type()==t) // of same type
3288 { // append to previous section ps
3289 }
3290 else // start new section
3291 {
3292 children().append<DocParamSect>(parser(),thisVariant(),t);
3293 ps = children().get_last<DocParamSect>();
3294 }
3295 Token rv=ps->parse(cmdName,xmlContext,
3296 static_cast<DocParamSect::Direction>(direction));
3297 AUTO_TRACE_EXIT("retval={}",rv.to_string());
3298 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3299}
DocParamSect::parse
Token parse(const QCString &cmdName, bool xmlContext, Direction d)
Definition docnode.cpp:3199
DocParamSect::type
Type type() const
Definition docnode.h:1063

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleRef()

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

Definition at line 3731 of file docnode.cpp.

3732{
3733 AUTO_TRACE("cmdName={}",cmdName);
3734 QCString saveCmdName = cmdName;
3735 Token tok=parser()->tokenizer.lex();
3736 if (!tok.is(TokenRetval::TK_WHITESPACE))
3737 {
3738 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3739 cmdChar,qPrint(saveCmdName));
3740 return;
3741 }
3742 parser()->tokenizer.setStateRef();
3743 tok=parser()->tokenizer.lex(); // get the reference id
3744 if (!tok.is(TokenRetval::TK_WORD))
3745 {
3746 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3747 tok.to_string(),cmdChar,saveCmdName);
3748 goto endref;
3749 }
3750 children().append<DocRef>(parser(),thisVariant(),
3751 parser()->context.token->name,
3752 parser()->context.context);
3753 children().get_last<DocRef>()->parse();
3754endref:
3755 parser()->tokenizer.setStatePara();
3756}
qPrint
const char * qPrint(const char *s)
Definition qcstring.h:672

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

Referenced by handleCommand().

◆ handleSection()

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

Definition at line 3863 of file docnode.cpp.

3864{
3865 AUTO_TRACE("cmdName={}",cmdName);
3866 QCString saveCmdName = cmdName;
3867 // get the argument of the section command.
3868 Token tok=parser()->tokenizer.lex();
3869 if (!tok.is(TokenRetval::TK_WHITESPACE))
3870 {
3871 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3872 cmdChar,saveCmdName);
3873 return;
3874 }
3875 tok=parser()->tokenizer.lex();
3876 if (tok.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3877 {
3878 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected end of comment block while parsing the "
3879 "argument of command '{:c}{}'", cmdChar,saveCmdName);
3880 return;
3881 }
3882 else if (!tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD))
3883 {
3884 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"unexpected token {} as the argument of '{:c}{}'",
3885 tok.to_string(),cmdChar,saveCmdName);
3886 return;
3887 }
3888 parser()->context.token->sectionId = parser()->context.token->name;
3889 parser()->tokenizer.setStateSkipTitle();
3890 parser()->tokenizer.lex();
3891 parser()->tokenizer.setStatePara();
3892}
DocTokenizer::setStateSkipTitle
void setStateSkipTitle()
Definition doctokenizer.l:2067

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

3484{
3485 AUTO_TRACE();
3486 QCString fmt;
3487 QCString date;
3488 Token tok=parser()->tokenizer.lex();
3489 if (!tok.is(TokenRetval::TK_WHITESPACE))
3490 {
3491 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"expected whitespace after '{:c}{}' command",
3492 cmdChar,cmdName);
3493 return;
3494 }
3495 parser()->tokenizer.setStateQuotedString();
3496 tok = parser()->tokenizer.lex();
3497 if (!tok.is(TokenRetval::TK_WORD))
3498 {
3499 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <format> argument for command '{:c}{}'",
3500 cmdChar,cmdName);
3501 parser()->tokenizer.setStatePara();
3502 return;
3503 }
3504 fmt = parser()->context.token->name;
3505
3506 parser()->tokenizer.setStateShowDate();
3507 tok = parser()->tokenizer.lex();
3508
3509 QCString specDateRaw = tok.is(TokenRetval::TK_WORD) ? parser()->context.token->name : QCString();
3510 QCString specDate = specDateRaw.stripWhiteSpace();
3511 bool specDateOnlyWS = !specDateRaw.isEmpty() && specDate.isEmpty();
3512 if (!specDate.isEmpty() && !tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3513 {
3514 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}'",
3515 cmdChar,cmdName);
3516 parser()->tokenizer.setStatePara();
3517 return;
3518 }
3519
3520 std::tm dat{};
3521 int specFormat=0;
3522 QCString err = dateTimeFromString(specDate,dat,specFormat);
3523 if (!err.isEmpty())
3524 {
3525 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"invalid <date_time> argument for command '{:c}{}': {}",
3526 cmdChar,cmdName,err);
3527 parser()->tokenizer.setStatePara();
3528 return;
3529 }
3530
3531 int usedFormat=0;
3532 QCString dateTimeStr = formatDateTime(fmt,dat,usedFormat);
3533
3534 // warn the user if the format contains markers that are not explicitly filled in
3535 for (int i=0;i<SF_NumBits;i++)
3536 {
3537 int bitMask = 1<<i;
3538 if ((usedFormat&bitMask) && !(specFormat&bitMask)) // a part was used in the format string but its value was not specified.
3539 {
3540 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.",
3541 cmdChar,cmdName,fmt,SF_bit2str(i),specDate,SF_bit2str(i));
3542 }
3543 }
3544
3545 children().append<DocWord>(parser(),thisVariant(),dateTimeStr);
3546 if (specDateOnlyWS) // specDate is only whitespace
3547 {
3548 children().append<DocWhiteSpace>(parser(),thisVariant()," ");
3549 }
3550 parser()->tokenizer.setStatePara();
3551}
DocTokenizer::setStateShowDate
void setStateShowDate()
Definition doctokenizer.l:2141
DocTokenizer::setStateQuotedString
void setStateQuotedString()
Definition doctokenizer.l:2134
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:175
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:134
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 3248 of file docnode.cpp.

3249{
3250 AUTO_TRACE();
3251 DocSimpleSect *ss=nullptr;
3252 bool needsSeparator = FALSE;
3253 if (!children().empty() && // has previous element
3254 (ss=children().get_last<DocSimpleSect>()) && // was a simple sect
3255 ss->type()==t && // of same type
3256 t!=DocSimpleSect::User) // but not user defined
3257 {
3258 // append to previous section
3259 needsSeparator = TRUE;
3260 }
3261 else // start new section
3262 {
3263 children().append<DocSimpleSect>(parser(),thisVariant(),t);
3264 ss = children().get_last<DocSimpleSect>();
3265 }
3266 Token rv = Token::make_RetVal_OK();
3267 if (xmlContext)
3268 {
3269 return ss->parseXml();
3270 }
3271 else
3272 {
3273 rv = ss->parse(t==DocSimpleSect::User,needsSeparator);
3274 }
3275 return (!rv.is(TokenRetval::TK_NEWPARA)) ? rv : Token::make_RetVal_OK();
3276}
DocSimpleSect::parse
Token parse(bool userTitle, bool needsSeparator)
Definition docnode.cpp:2913
DocSimpleSect::parseXml
Token parseXml()
Definition docnode.cpp:2967

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleStartCode()

Token DocPara::handleStartCode ( )

Definition at line 3912 of file docnode.cpp.

3913{
3914 AUTO_TRACE();
3915 Token retval = parser()->tokenizer.lex();
3916 QCString lang = parser()->context.token->name;
3917 if (!lang.isEmpty() && lang.at(0)!='.')
3918 {
3919 lang="."+lang;
3920 }
3921 if (parser()->context.xmlComment)
3922 {
3923 parser()->context.token->verb = substitute(substitute(parser()->context.token->verb,"&lt;","<"),"&gt;",">");
3924 }
3925 // search for the first non-whitespace line, index is stored in li
3926 size_t i=0,li=0,l=parser()->context.token->verb.length();
3927 while (i<l && (parser()->context.token->verb.at(i)==' ' || parser()->context.token->verb.at(i)=='\n'))
3928 {
3929 if (parser()->context.token->verb.at(i)=='\n') li=i+1;
3930 i++;
3931 }
3932 children().append<DocVerbatim>(parser(),thisVariant(),
3933 parser()->context.context,
3934 stripIndentation(parser()->context.token->verb.mid(li)),
3935 DocVerbatim::Code,
3936 parser()->context.isExample,
3937 parser()->context.exampleName,
3938 FALSE,lang);
3939 if (retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF))
3940 {
3941 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"code section ended without end marker");
3942 }
3943 parser()->tokenizer.setStatePara();
3944 AUTO_TRACE_EXIT("retval={}",retval.to_string());
3945 return retval;
3946}
QCString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
substitute
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:477
stripIndentation
QCString stripIndentation(const QCString &s, bool skipFirstLine)
Definition util.cpp:6428

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

Referenced by handleCommand(), and handleHtmlStartTag().

◆ handleVhdlFlow()

void DocPara::handleVhdlFlow ( )

Definition at line 3683 of file docnode.cpp.

3684{
3685 AUTO_TRACE();
3686 children().append<DocVhdlFlow>(parser(),thisVariant());
3687 children().get_last<DocVhdlFlow>()->parse();
3688}

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

3463{
3464 AUTO_TRACE();
3465 Token retval=parser()->tokenizer.lex();
3466 ASSERT(retval.is(TokenRetval::TK_WHITESPACE));
3467 parser()->tokenizer.setStateXRefItem();
3468 retval=parser()->tokenizer.lex();
3469 if (retval.is(TokenRetval::RetVal_OK))
3470 {
3471 children().append<DocXRefItem>(parser(),thisVariant(),
3472 parser()->context.token->id,parser()->context.token->name);
3473 DocXRefItem *ref = children().get_last<DocXRefItem>();
3474 if (!ref->parse())
3475 {
3476 children().pop_back();
3477 }
3478 }
3479 parser()->tokenizer.setStatePara();
3480 return retval;
3481}
DocTokenizer::setStateXRefItem
void setStateXRefItem()
Definition doctokenizer.l:1996

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

3906{
3907 AUTO_TRACE();
3908 parser()->context.token->name = tokText;
3909 return parser()->defaultHandleToken(thisVariant(),tok,children());
3910}
DocParser::defaultHandleToken
bool defaultHandleToken(DocNodeVariant *parent, Token tok, DocNodeList &children, bool handleWord=TRUE)
Definition docparser.cpp:1209

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 1079 of file docnode.h.

1079{ 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 1082 of file docnode.h.

1082{ return m_isFirst; }

References m_isFirst.

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

◆ isLast()

bool DocPara::isLast ( ) const
inline

Definition at line 1083 of file docnode.h.

1083{ 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 1080 of file docnode.h.

1080{ m_isFirst=v; }

References m_isFirst, and TRUE.

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

◆ markLast()

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

Definition at line 1081 of file docnode.h.

1081{ m_isLast=v; }

References m_isLast, and TRUE.

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

◆ parse()

Token DocPara::parse ( )

Definition at line 5479 of file docnode.cpp.

5480{
5481 AUTO_TRACE();
5482 auto ns = AutoNodeStack(parser(),thisVariant());
5483 // handle style commands "inherited" from the previous paragraph
5484 parser()->handleInitialStyleCommands(thisVariant(),children());
5485 Token tok=parser()->tokenizer.lex();
5486 Token retval = Token::make_TK_NONE();
5487 while (!tok.is_any_of(TokenRetval::TK_NONE, TokenRetval::TK_EOF)) // get the next token
5488 {
5489reparsetoken:
5490 AUTO_TRACE_ADD("token '{}' at {}",tok.to_string(),parser()->tokenizer.getLineNr());
5491 if (tok.is_any_of(TokenRetval::TK_WORD,TokenRetval::TK_LNKWORD,TokenRetval::TK_SYMBOL,TokenRetval::TK_URL,
5492 TokenRetval::TK_COMMAND_AT,TokenRetval::TK_COMMAND_BS,TokenRetval::TK_HTMLTAG)
5493 )
5494 {
5495 AUTO_TRACE_ADD("name={}",parser()->context.token->name);
5496 }
5497 switch(tok.value())
5498 {
5499 case TokenRetval::TK_WORD:
5500 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
5501 break;
5502 case TokenRetval::TK_LNKWORD:
5503 parser()->handleLinkedWord(thisVariant(),children());
5504 break;
5505 case TokenRetval::TK_URL:
5506 children().append<DocURL>(parser(),thisVariant(),parser()->context.token->name,parser()->context.token->isEMailAddr);
5507 break;
5508 case TokenRetval::TK_WHITESPACE:
5509 {
5510 // prevent leading whitespace and collapse multiple whitespace areas
5511 if (insidePRE(thisVariant()) || // all whitespace is relevant
5512 (
5513 // remove leading whitespace
5514 !children().empty() &&
5515 // and whitespace after certain constructs
5516 !holds_one_of_alternatives<DocHtmlDescList, DocHtmlTable, DocHtmlList, DocSimpleSect,
5517 DocAutoList, DocSimpleList, DocHtmlHeader, DocHtmlBlockQuote,
5518 DocParamSect, DocHtmlDetails, DocXRefItem>(children().back())
5519 )
5520 )
5521 {
5522 children().append<DocWhiteSpace>(parser(),thisVariant(),parser()->context.token->chars);
5523 }
5524 }
5525 break;
5526 case TokenRetval::TK_LISTITEM:
5527 {
5528 AUTO_TRACE_ADD("found list item at {}",parser()->context.token->indent);
5529 const DocNodeVariant *n=parent();
5530 while (n && !std::holds_alternative<DocAutoList>(*n)) n=::parent(n);
5531 const DocAutoList *al = std::get_if<DocAutoList>(n);
5532 if (al) // we found an auto list up in the hierarchy
5533 {
5534 AUTO_TRACE_ADD("previous list item at {}",al->indent());
5535 if (al->indent()>=parser()->context.token->indent)
5536 // new item at the same or lower indent level
5537 {
5538 retval = Token::make_TK_LISTITEM();
5539 goto endparagraph;
5540 }
5541 }
5542
5543 // determine list depth
5544 int depth = 0;
5545 n=parent();
5546 while (n)
5547 {
5548 al = std::get_if<DocAutoList>(n);
5549 if (al && al->isEnumList()) depth++;
5550 n=::parent(n);
5551 }
5552
5553 // first item or sub list => create new list
5554 do
5555 {
5556 children().append<DocAutoList>(parser(),thisVariant(),
5557 parser()->context.token->indent,
5558 parser()->context.token->isEnumList,depth,
5559 parser()->context.token->isCheckedList);
5560 al = children().get_last<DocAutoList>();
5561 retval = children().get_last<DocAutoList>()->parse();
5562 } while (retval.is(TokenRetval::TK_LISTITEM) && // new list
5563 al->indent()==parser()->context.token->indent // at same indent level
5564 );
5565
5566 // check the return value
5567 if (retval.is(TokenRetval::RetVal_SimpleSec)) // auto list ended due to simple section command
5568 {
5569 // Reparse the token that ended the section at this level,
5570 // so a new simple section will be started at this level.
5571 // This is the same as unputting the last read token and continuing.
5572 parser()->context.token->name = parser()->context.token->simpleSectName;
5573 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5574 {
5575 parser()->context.token->name = parser()->context.token->name.mid(4);
5576 parser()->context.token->text = parser()->context.token->simpleSectText;
5577 tok = Token::make_TK_RCSTAG();
5578 }
5579 else // other section
5580 {
5581 tok = Token::make_TK_COMMAND_BS();
5582 }
5583 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5584 goto reparsetoken;
5585 }
5586 else if (retval.is(TokenRetval::TK_ENDLIST))
5587 {
5588 if (al->indent()>parser()->context.token->indent) // end list
5589 {
5590 goto endparagraph;
5591 }
5592 else // continue with current paragraph
5593 {
5594 }
5595 }
5596 else // paragraph ended due to TokenRetval::TK_NEWPARA, TokenRetval::TK_LISTITEM, or EOF
5597 {
5598 goto endparagraph;
5599 }
5600 }
5601 break;
5602 case TokenRetval::TK_ENDLIST:
5603 AUTO_TRACE_ADD("Found end of list inside of paragraph at line {}",parser()->tokenizer.getLineNr());
5604 if (std::get_if<DocAutoListItem>(parent()))
5605 {
5606 const DocAutoList *al = std::get_if<DocAutoList>(::parent(parent()));
5607 if (al && al->indent()>=parser()->context.token->indent)
5608 {
5609 // end of list marker ends this paragraph
5610 retval = Token::make_TK_ENDLIST();
5611 goto endparagraph;
5612 }
5613 else
5614 {
5615 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found "
5616 "has invalid indent level");
5617 }
5618 }
5619 else
5620 {
5621 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"End of list marker found without any preceding "
5622 "list items");
5623 }
5624 break;
5625 case TokenRetval::TK_COMMAND_AT:
5626 // fall through
5627 case TokenRetval::TK_COMMAND_BS:
5628 {
5629 // see if we have to start a simple section
5630 CommandType cmd = Mappers::cmdMapper->map(parser()->context.token->name);
5631 const DocNodeVariant *n=parent();
5632 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5633 !std::holds_alternative<DocParamSect>(*n))
5634 {
5635 n=::parent(n);
5636 }
5637 if (cmd>CommandType::SIMPLESECT_BIT)
5638 {
5639 if (n) // already in a simple section
5640 {
5641 // simple section cannot start in this paragraph, need
5642 // to unwind the stack and remember the command.
5643 parser()->context.token->simpleSectName = parser()->context.token->name;
5644 retval = Token::make_RetVal_SimpleSec();
5645 goto endparagraph;
5646 }
5647 }
5648 // see if we are in a simple list
5649 n=parent();
5650 while (n && !std::holds_alternative<DocSimpleListItem>(*n)) n=::parent(n);
5651 if (n)
5652 {
5653 if (cmd==CommandType::CMD_LI)
5654 {
5655 retval = Token::make_RetVal_ListItem();
5656 goto endparagraph;
5657 }
5658 }
5659
5660 // handle the command
5661 retval=handleCommand(tok.command_to_char(),parser()->context.token->name);
5662 AUTO_TRACE_ADD("handleCommand returns {}",retval.to_string());
5663
5664 // check the return value
5665 if (retval.is(TokenRetval::RetVal_SimpleSec))
5666 {
5667 // Reparse the token that ended the section at this level,
5668 // so a new simple section will be started at this level.
5669 // This is the same as unputting the last read token and continuing.
5670 parser()->context.token->name = parser()->context.token->simpleSectName;
5671 if (parser()->context.token->name.startsWith("rcs:")) // RCS section
5672 {
5673 parser()->context.token->name = parser()->context.token->name.mid(4);
5674 parser()->context.token->text = parser()->context.token->simpleSectText;
5675 tok = Token::make_TK_RCSTAG();
5676 }
5677 else // other section
5678 {
5679 tok = Token::make_TK_COMMAND_BS();
5680 }
5681 AUTO_TRACE_ADD("reparsing command {}",parser()->context.token->name);
5682 goto reparsetoken;
5683 }
5684 else if (retval.value()>TokenRetval::TK_NONE && retval.value()<TokenRetval::RetVal_OK)
5685 {
5686 // the command ended with a new command, reparse this token
5687 tok = retval;
5688 goto reparsetoken;
5689 }
5690 else if (retval.value()!=TokenRetval::RetVal_OK) // end of file, end of paragraph, start or end of section
5691 // or some auto list marker
5692 {
5693 goto endparagraph;
5694 }
5695 }
5696 break;
5697 case TokenRetval::TK_HTMLTAG:
5698 {
5699 if (!parser()->context.token->endTag) // found a start tag
5700 {
5701 retval = handleHtmlStartTag(parser()->context.token->name,parser()->context.token->attribs);
5702 }
5703 else // found an end tag
5704 {
5705 if (checkIfHtmlEndTagEndsAutoList(parser(),parent()))
5706 {
5707 break; // new code has been pushed back to the scanner, need to reparse
5708 }
5709 retval = handleHtmlEndTag(parser()->context.token->name);
5710 }
5711 if (!retval.is(TokenRetval::RetVal_OK))
5712 {
5713 goto endparagraph;
5714 }
5715 }
5716 break;
5717 case TokenRetval::TK_SYMBOL:
5718 {
5719 HtmlEntityMapper::SymType s = DocSymbol::decodeSymbol(parser()->context.token->name);
5720 if (s!=HtmlEntityMapper::Sym_Unknown)
5721 {
5722 children().append<DocSymbol>(parser(),thisVariant(),s);
5723 }
5724 else
5725 {
5726 children().append<DocWord>(parser(),thisVariant(),parser()->context.token->name);
5727 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),"Unsupported symbol '{}' found",
5728 parser()->context.token->name);
5729 }
5730 break;
5731 }
5732 case TokenRetval::TK_NEWPARA:
5733 retval = Token::make_TK_NEWPARA();
5734 goto endparagraph;
5735 case TokenRetval::TK_RCSTAG:
5736 {
5737 const DocNodeVariant *n=parent();
5738 while (n && !std::holds_alternative<DocSimpleSect>(*n) &&
5739 !std::holds_alternative<DocParamSect>(*n))
5740 {
5741 n=::parent(n);
5742 }
5743 if (n) // already in a simple section
5744 {
5745 // simple section cannot start in this paragraph, need
5746 // to unwind the stack and remember the command.
5747 parser()->context.token->simpleSectName = "rcs:"+parser()->context.token->name;
5748 parser()->context.token->simpleSectText = parser()->context.token->text;
5749 retval = Token::make_RetVal_SimpleSec();
5750 goto endparagraph;
5751 }
5752
5753 // see if we are in a simple list
5754 children().append<DocSimpleSect>(parser(),thisVariant(),DocSimpleSect::Rcs);
5755 children().get_last<DocSimpleSect>()->parseRcs();
5756 }
5757 break;
5758 default:
5759 warn_doc_error(parser()->context.fileName,parser()->tokenizer.getLineNr(),
5760 "Found unexpected token (id={})",tok.to_string());
5761 break;
5762 }
5763 tok=parser()->tokenizer.lex();
5764 }
5765 retval=Token::make_TK_NONE();
5766endparagraph:
5767 parser()->handlePendingStyleCommands(thisVariant(),children());
5768 DocPara *par = std::get_if<DocPara>(parser()->context.nodeStack.top());
5769 if (!parser()->context.token->endTag && par &&
5770 retval.is(TokenRetval::TK_NEWPARA) && parser()->context.token->name.lower() == "p")
5771 {
5772 par->setAttribs(parser()->context.token->attribs);
5773 }
5774 INTERNAL_ASSERT(retval.is_any_of(TokenRetval::TK_NONE,TokenRetval::TK_EOF,TokenRetval::TK_NEWPARA,TokenRetval::TK_LISTITEM,
5775 TokenRetval::TK_ENDLIST,TokenRetval::RetVal_OK)
5776 );
5777
5778 AUTO_TRACE_EXIT("retval={}",retval.to_string());
5779 return retval;
5780}
DocAutoList::isEnumList
bool isEnumList() const
Definition docnode.h:576
DocAutoList::indent
int indent() const
Definition docnode.h:577
DocPara::DocPara
DocPara(DocParser *parser, DocNodeVariant *parent)
Definition docnode.cpp:3242
DocPara::handleCommand
Token handleCommand(char cmdChar, const QCString &cmdName)
Definition docnode.cpp:3985
DocPara::handleHtmlStartTag
Token handleHtmlStartTag(const QCString &tagName, const HtmlAttribList &tagHtmlAttribs)
Definition docnode.cpp:4735
DocPara::setAttribs
void setAttribs(const HtmlAttribList &attribs)
Definition docnode.h:1110
DocPara::handleHtmlEndTag
Token handleHtmlEndTag(const QCString &tagName)
Definition docnode.cpp:5206
DocParser::handleInitialStyleCommands
void handleInitialStyleCommands(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:697
DocParser::handlePendingStyleCommands
void handlePendingStyleCommands(DocNodeVariant *parent, DocNodeList &children)
Definition docparser.cpp:680
DocSymbol::decodeSymbol
static HtmlEntityMapper::SymType decodeSymbol(const QCString &symName)
Definition docnode.cpp:153
Token::value
TokenRetval value() const
Definition doctokenizer.h:85
Token::command_to_char
char command_to_char() const
Definition doctokenizer.h:104
AUTO_TRACE_ADD
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
checkIfHtmlEndTagEndsAutoList
static bool checkIfHtmlEndTagEndsAutoList(DocParser *parser, const DocNodeVariant *n)
Definition docnode.cpp:5427
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:1361
insidePRE
bool insidePRE(const DocNodeVariant *n)
Definition docparser_p.h:177
TokenInfo::isEnumList
bool isEnumList
Definition doctokenizer.h:144
TokenInfo::text
QCString text
Definition doctokenizer.h:139
TokenInfo::chars
QCString chars
Definition doctokenizer.h:168
TokenInfo::isCheckedList
bool isCheckedList
Definition doctokenizer.h:145
TokenInfo::simpleSectText
QCString simpleSectText
Definition doctokenizer.h:153
TokenInfo::isEMailAddr
bool isEMailAddr
Definition doctokenizer.h:171
TokenInfo::simpleSectName
QCString simpleSectName
Definition doctokenizer.h:152

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(), handleRef(), 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 1110 of file docnode.h.

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

References attribs(), and m_attribs.

Referenced by parse().

Member Data Documentation

◆ m_attribs

HtmlAttribList DocPara::m_attribs
private

Definition at line 1115 of file docnode.h.

Referenced by attribs(), and setAttribs().

◆ m_isFirst

bool DocPara::m_isFirst = false
private

Definition at line 1113 of file docnode.h.

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

◆ m_isLast

bool DocPara::m_isLast = false
private

Definition at line 1114 of file docnode.h.

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

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