Doxygen
Loading...
Searching...
No Matches
sqlcode.l
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2020 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16%option never-interactive
17%option prefix="sqlcodeYY"
18%option noyywrap
19%option nounput
20%option reentrant
21%option extra-type="struct sqlcodeYY_state *"
22%top{
23#include <stdint.h>
24// forward declare yyscan_t to improve type safety
25#define YY_TYPEDEF_YY_SCANNER_T
26struct yyguts_t;
27typedef yyguts_t *yyscan_t;
yyguts_t * yyscan_t
Definition code.l:24
28}
29
30%{
31
32#include <stdio.h>
33
34#include "sqlcode.h"
35
36#include "entry.h"
37#include "doxygen.h"
38#include "outputlist.h"
39#include "util.h"
40#include "membername.h"
41#include "searchindex.h"
42#include "config.h"
43#include "filedef.h"
44#include "tooltip.h"
45#include "message.h"
46#include "debug.h"
47
48#define YY_NEVER_INTERACTIVE 1
49#define YY_NO_INPUT 1
50#define YY_NO_UNISTD_H 1
51
53{
54 OutputCodeList * code = nullptr;
55 const char *inputString = nullptr; //!< the code fragment as text
56 int inputPosition = 0; //!< read offset during parsing
58 int inputLines = 0; //!< number of line in the code fragment
59 int yyLineNr = 1; //!< current line number
60 bool insideCodeLine = false;
61 const Definition *searchCtx = nullptr;
62
63 bool stripCodeComments = true;
64 bool exampleBlock = false;
67
68 std::unique_ptr<FileDef> exampleFileDef;
69 const FileDef *sourceFileDef = nullptr;
70 const Definition *currentDefinition = nullptr;
71 const MemberDef *currentMemberDef = nullptr;
72 bool includeCodeFragment = false;
73 const char *currentFontClass = nullptr;
74};
75
76[[maybe_unused]] static const char *stateToString(int state);
77
78static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor);
79static void startCodeLine(yyscan_t yyscanner);
80static void endFontClass(yyscan_t yyscanner);
81static void endCodeLine(yyscan_t yyscanner);
82static void nextCodeLine(yyscan_t yyscanner);
83static void codifyLines(yyscan_t yyscanner,const char *text);
84static void startFontClass(yyscan_t yyscanner,const char *s);
85static int countLines(yyscan_t yyscanner);
86static int yyread(yyscan_t yyscanner,char *buf,int max_size);
87
88#undef YY_INPUT
89#define YY_INPUT(buf,result,max_size) result=yyread(yyscanner,buf,max_size);
90
91// otherwise the filename would be the name of the converted file (*.cpp instead of *.l)
92static inline const char *getLexerFILE() {return __FILE__;}
93#include "doxygen_lex.h"
94
The common base class of all entity definitions found in the sources.
Definition definition.h:76
A model of a file symbol.
Definition filedef.h:99
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
Class representing a list of different code generators.
Definition outputlist.h:164
This is an alternative implementation of QCString.
Definition qcstring.h:101
Web server based search engine.
static void endCodeLine(yyscan_t yyscanner)
Definition sqlcode.l:287
static void nextCodeLine(yyscan_t yyscanner)
Definition sqlcode.l:295
static void startCodeLine(yyscan_t yyscanner)
Definition sqlcode.l:230
static int yyread(yyscan_t yyscanner, char *buf, int max_size)
Definition sqlcode.l:363
static int countLines(yyscan_t yyscanner)
Definition sqlcode.l:344
static const char * stateToString(int state)
static void startFontClass(yyscan_t yyscanner, const char *s)
Definition sqlcode.l:335
static void codifyLines(yyscan_t yyscanner, const char *text)
Definition sqlcode.l:310
static const char * getLexerFILE()
Definition sqlcode.l:92
static void setCurrentDoc(yyscan_t yyscanner, const QCString &anchor)
Definition sqlcode.l:210
static void endFontClass(yyscan_t yyscanner)
Definition sqlcode.l:277
const char * currentFontClass
Definition sqlcode.l:73
const Definition * searchCtx
Definition sqlcode.l:61
bool includeCodeFragment
Definition sqlcode.l:72
bool exampleBlock
Definition sqlcode.l:64
const char * inputString
the code fragment as text
Definition sqlcode.l:55
QCString fileName
Definition sqlcode.l:57
const MemberDef * currentMemberDef
Definition sqlcode.l:71
bool insideCodeLine
Definition sqlcode.l:60
QCString classScope
Definition sqlcode.l:66
int yyLineNr
current line number
Definition sqlcode.l:59
QCString exampleName
Definition sqlcode.l:65
OutputCodeList * code
Definition sqlcode.l:54
int inputLines
number of line in the code fragment
Definition sqlcode.l:58
const FileDef * sourceFileDef
Definition sqlcode.l:69
std::unique_ptr< FileDef > exampleFileDef
Definition sqlcode.l:68
int inputPosition
read offset during parsing
Definition sqlcode.l:56
bool stripCodeComments
Definition sqlcode.l:63
const Definition * currentDefinition
Definition sqlcode.l:70
A bunch of utility functions.
95%}
96
97nl (\r\n|\r|\n)
98idchar [A-Za-z0-9\-_]+
99keywords1 ("ADD"|"ALL"|"ALLOCATE"|"ALTER"|"AND"|"ANY"|"ARE"|"AS"|"ASENSITIVE"|"ASYMMETRIC"|"AT"|"ATOMIC"|"AUTHORIZATION"|"BETWEEN"|"BOTH"|"BY"|"CALL"|"CALLED"|"CASCADED"|"CAST")
100keywords2 ("CHECK"|"CLOSE"|"COLLATE"|"COLUMN"|"COMMIT"|"CONNECT"|"CONSTRAINT"|"CONTINUE"|"CORRESPONDING"|"CREATE"|"CROSS"|"CUBE"|"CURRENT"|"CURRENT_DATE"|"CURRENT_DEFAULT_TRANSFORM_GROUP")
101keywords3 ("CURRENT_PATH"|"CURRENT_ROLE"|"CURRENT_TIME"|"CURRENT_TIMESTAMP"|"CURRENT_TRANSFORM_GROUP_FOR_TYPE"|"CURRENT_USER")
102keywords4 ("CURSOR"|"CYCLE"|"DAY"|"DEALLOCATE"|"DECLARE"|"DEFAULT"|"DELETE"|"DEREF"|"DESCRIBE"|"DETERMINISTIC"|"DISCONNECT"|"DISTINCT"|"DROP"|"DYNAMIC")
103keywords5 ("EACH"|"ELEMENT"|"END-EXEC"|"ESCAPE"|"EXCEPT"|"EXEC"|"EXECUTE"|"EXISTS"|"EXTERNAL"|"FETCH"|"FILTER"|"FOR"|"FOREIGN"|"FREE"|"FROM"|"FULL"|"FUNCTION")
104keywords6 ("GET"|"GLOBAL"|"GRANT"|"GROUP"|"GROUPING"|"HAVING"|"HOLD"|"HOUR"|"IDENTITY"|"IMMEDIATE"|"IN"|"INDICATOR"|"INNER"|"INOUT"|"INPUT"|"INSENSITIVE"|"INSERT"|"INTERSECT")
105keywords7 ("INTERVAL"|"INTO"|"IS"|"ISOLATION"|"JOIN"|"LANGUAGE"|"LARGE"|"LATERAL"|"LEADING"|"LEFT"|"LIKE"|"LOCAL"|"LOCALTIME"|"LOCALTIMESTAMP"|"MATCH"|"MEMBER"|"MERGE"|"METHOD"|"MINUTE")
106keywords8 ("MODIFIES"|"MODULE"|"MONTH"|"MULTISET"|"NATIONAL"|"NATURAL"|"NEW"|"NO"|"NONE"|"NOT"|"OF"|"OLD"|"ON"|"ONLY"|"OPEN"|"OR"|"ORDER"|"OUT"|"OUTER"|"OUTPUT")
107keywords9 ("OVER"|"OVERLAPS"|"PARAMETER"|"PARTITION"|"PRECISION"|"PREPARE"|"PRIMARY"|"PROCEDURE"|"RANGE"|"READS"|"RECURSIVE"|"REF"|"REFERENCES"|"REFERENCING"|"REGR_AVGX"|"REGR_AVGY")
108keywords10 ("REGR_COUNT"|"REGR_INTERCEPT"|"REGR_R2"|"REGR_SLOPE"|"REGR_SXX"|"REGR_SXY"|"REGR_SYY"|"RELEASE"|"RESULT"|"RETURN"|"RETURNS"|"REVOKE"|"RIGHT"|"ROLLBACK"|"ROLLUP"|"ROW"|"ROWS"|"SAVEPOINT")
109keywords11 ("SCROLL"|"SEARCH"|"SECOND"|"SELECT"|"SENSITIVE"|"SESSION_USER"|"SET"|"SIMILAR"|"SOME"|"SPECIFIC"|"SPECIFICTYPE"|"SQL"|"SQLEXCEPTION"|"SQLSTATE"|"SQLWARNING"|"START"|"STATIC")
110keywords12 ("SUBMULTISET"|"SYMMETRIC"|"SYSTEM"|"SYSTEM_USER"|"TABLE"|"THEN"|"TIMEZONE_HOUR"|"TIMEZONE_MINUTE"|"TO"|"TRAILING"|"TRANSLATION"|"TREAT"|"TRIGGER"|"UESCAPE"|"UNION")
111keywords13 ("UNIQUE"|"UNNEST"|"UPDATE"|"UPPER"|"USER"|"USING"|"VALUE"|"VALUES"|"VAR_POP"|"VAR_SAMP"|"VARYING"|"WHEN"|"WHENEVER"|"WHERE"|"WIDTH_BUCKET"|"WINDOW"|"WITH"|"WITHIN"|"WITHOUT"|"YEAR")
112
113/* Need multiple keyword definitions due to max length */
114keyword (?i:{keywords1}|{keywords2}|{keywords3}|{keywords4}|{keywords5}|{keywords6}|{keywords7}|{keywords8}|{keywords9}|{keywords10}|{keywords11}|{keywords12}|{keywords13})
115
116typekeyword (?i:"ARRAY"|"BIGINT"|"BINARY"|"BLOB"|"BOOLEAN"|"CHAR"|"CHARACTER"|"CLOB"|"DATE"|"DEC"|"DECIMAL"|"DOUBLE"|"FLOAT"|"INT"|"INTEGER"|"NCHAR"|"NCLOB"|"NUMERIC"|"NVARCHAR"|"REAL"|"SMALLINT"|"TIME"|"TIMESTAMP"|"VARCHAR")
117
118flowkeyword (?i:"CASE"|"IF"|"ELSE"|"BEGIN"|"END"|"WHILE")
119
120literalkeyword (?i:"false"|"true"|"NULL"|"UNKNOWN")
121stringliteral (\"[^\"]*\")|('[^']*')
122number [0-9]+
123literals ({literalkeyword}|{stringliteral}|{number})
124
125variable @{idchar}+
126
127simplecomment --.*
128commentopen "/\*"
129commentclose "\*\/"
130
131%x COMMENT
132
134
135{literals} {
136 startFontClass(yyscanner,"stringliteral");
137 codifyLines(yyscanner,yytext);
138 endFontClass(yyscanner);
139 }
static void codifyLines(yyscan_t yyscanner, const QCString &text)
Definition code.l:2505
static void startFontClass(yyscan_t yyscanner, const char *s, bool specialComment=false)
Definition code.l:3487
static void endFontClass(yyscan_t yyscanner, bool specialComment=false)
Definition code.l:3472
140
141
142{keyword} {
143 startFontClass(yyscanner,"keyword");
144 codifyLines(yyscanner,yytext);
145 endFontClass(yyscanner);
146 }
147
148{flowkeyword} {
149 startFontClass(yyscanner,"keywordflow");
150 codifyLines(yyscanner,yytext);
151 endFontClass(yyscanner);
152 }
153
154{typekeyword} {
155 startFontClass(yyscanner,"keywordtype");
156 codifyLines(yyscanner,yytext);
157 endFontClass(yyscanner);
158 }
159
160{variable} {
161 startFontClass(yyscanner,"preprocessor");
162 codifyLines(yyscanner,yytext);
163 endFontClass(yyscanner);
164 }
165
166{simplecomment} {
167 startFontClass(yyscanner,"comment");
168 codifyLines(yyscanner,yytext);
169 endFontClass(yyscanner);
170 }
171
172{commentopen} {
173 startFontClass(yyscanner,"comment");
174 codifyLines(yyscanner,yytext);
175 BEGIN(COMMENT);
176 }
177
178<COMMENT>. {
179 codifyLines(yyscanner,yytext);
180
181 }
182<COMMENT>{nl} {
183 codifyLines(yyscanner,yytext);
184 }
185
186<COMMENT>{commentclose} {
187 codifyLines(yyscanner,yytext);
188 endFontClass(yyscanner);
189 BEGIN(INITIAL);
190 }
191
192{idchar} {
193 codifyLines(yyscanner,yytext);
194 }
195
196{nl} {
197 codifyLines(yyscanner,yytext);
198 }
199
200[\x80-\xFF]* { // keep utf8 characters together...
201 codifyLines(yyscanner,yytext);
202 }
203. {
204 codifyLines(yyscanner,yytext);
205 }
206
207%%
208
209
210static void setCurrentDoc(yyscan_t yyscanner,const QCString &anchor)
211{
212 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
213 if (Doxygen::searchIndex.enabled())
214 {
215 if (yyextra->searchCtx)
216 {
217 Doxygen::searchIndex.setCurrentDoc(yyextra->searchCtx,yyextra->searchCtx->anchor(),false);
218 }
219 else
220 {
221 Doxygen::searchIndex.setCurrentDoc(yyextra->sourceFileDef,anchor,true);
222 }
223 }
224}
225
226/*! start a new line of code, inserting a line number if yyextra->sourceFileDef
227 * is true. If a definition starts at the current line, then the line
228 * number is linked to the documentation of that definition.
229 */
230static void startCodeLine(yyscan_t yyscanner)
231{
232 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
233 if (yyextra->sourceFileDef)
234 {
235 const Definition *d = yyextra->sourceFileDef->getSourceDefinition(yyextra->yyLineNr);
236
237 if (!yyextra->includeCodeFragment && d && d->isLinkableInProject())
238 {
239 yyextra->currentDefinition = d;
240 yyextra->currentMemberDef = yyextra->sourceFileDef->getSourceMember(yyextra->yyLineNr);
241 yyextra->classScope = d->name();
242 QCString lineAnchor;
243 lineAnchor.sprintf("l%05d",yyextra->yyLineNr);
244 if (yyextra->currentMemberDef)
245 {
246 yyextra->code->writeLineNumber(yyextra->currentMemberDef->getReference(),
247 yyextra->currentMemberDef->getOutputFileBase(),
248 yyextra->currentMemberDef->anchor(),yyextra->yyLineNr,
249 !yyextra->includeCodeFragment);
250 setCurrentDoc(yyscanner,lineAnchor);
251 }
252 else
253 {
254 yyextra->code->writeLineNumber(d->getReference(),
256 QCString(),yyextra->yyLineNr,
257 !yyextra->includeCodeFragment);
258 setCurrentDoc(yyscanner,lineAnchor);
259 }
260 }
261 else
262 {
263 yyextra->code->writeLineNumber(QCString(),QCString(),QCString(),yyextra->yyLineNr,
264 !yyextra->includeCodeFragment);
265 }
266 }
267
268 yyextra->code->startCodeLine(yyextra->yyLineNr);
269 yyextra->insideCodeLine=true;
270
271 if (yyextra->currentFontClass)
272 {
273 yyextra->code->startFontClass(yyextra->currentFontClass);
274 }
275}
276
277static void endFontClass(yyscan_t yyscanner)
278{
279 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
280 if (yyextra->currentFontClass)
281 {
282 yyextra->code->endFontClass();
283 yyextra->currentFontClass=0;
284 }
285}
286
287static void endCodeLine(yyscan_t yyscanner)
288{
289 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
290 endFontClass(yyscanner);
291 yyextra->code->endCodeLine();
292 yyextra->insideCodeLine=false;
293}
294
295static void nextCodeLine(yyscan_t yyscanner)
296{
297 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
298 const char *fc = yyextra->currentFontClass;
299 if (yyextra->insideCodeLine)
300 {
301 endCodeLine(yyscanner);
302 }
303 if (yyextra->yyLineNr<yyextra->inputLines)
304 {
305 yyextra->currentFontClass = fc;
306 startCodeLine(yyscanner);
307 }
308}
309
310static void codifyLines(yyscan_t yyscanner,const char *text)
311{
312 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
313 const char *p=text,*sp=p;
314 char c;
315 bool done=false;
316 while (!done)
317 {
318 sp=p;
319 while ((c=*p++) && c!='\n') { }
320 if (c=='\n')
321 {
322 yyextra->yyLineNr++;
323 size_t l = static_cast<size_t>(p-sp-1);
324 yyextra->code->codify(QCString(sp,l));
325 nextCodeLine(yyscanner);
326 }
327 else
328 {
329 yyextra->code->codify(sp);
330 done=true;
331 }
332 }
333}
334
335static void startFontClass(yyscan_t yyscanner,const char *s)
336{
337 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
338 endFontClass(yyscanner);
339 yyextra->code->startFontClass(s);
340 yyextra->currentFontClass=s;
341}
342
343/*! counts the number of lines in the input */
344static int countLines(yyscan_t yyscanner)
345{
346 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
347 const char *p=yyextra->inputString;
348 char c;
349 int count=1;
350 while ((c=*p))
351 {
352 p++ ;
353 if (c=='\n') count++;
354 }
355 if (p>yyextra->inputString && *(p-1)!='\n')
356 { // last line does not end with a \n, so we add an extra
357 // line and explicitly terminate the line after parsing.
358 count++;
359 }
360 return count;
361}
362
363static int yyread(yyscan_t yyscanner,char *buf,int max_size)
364{
365 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
366 int inputPosition = yyextra->inputPosition;
367 const char *s = yyextra->inputString + inputPosition;
368 int c=0;
369 while( c < max_size && *s )
370 {
371 *buf++ = *s++;
372 c++;
373 }
374 yyextra->inputPosition += c;
375 return c;
376}
377
378
379// public interface -----------------------------------------------------------
380
386
387SQLCodeParser::SQLCodeParser() : p(std::make_unique<Private>())
388{
389 sqlcodeYYlex_init_extra(&p->state, &p->yyscanner);
390#ifdef FLEX_DEBUG
391 sqlcodeYYset_debug(Debug::isFlagSet(Debug::Lex_sqlcode)?1:0,p->yyscanner);
392#endif
394}
395
397{
398 sqlcodeYYlex_destroy(p->yyscanner);
399}
400
402{
403 struct yyguts_t *yyg = (struct yyguts_t*)p->yyscanner;
404 yyextra->currentDefinition = nullptr;
405 yyextra->currentMemberDef = nullptr;
406}
407
409 const QCString &/* scopeName */,
410 const QCString &input,
412 bool stripCodeComments,
413 bool isExampleBlock,
414 const QCString &exampleName,
415 const FileDef *fileDef,
416 int startLine,
417 int endLine,
418 bool inlineFragment,
419 const MemberDef * /* memberDef */,
420 bool /* showLineNumbers */,
421 const Definition *searchCtx,
422 bool/* collectXRefs */
423 )
424{
425 yyscan_t yyscanner = p->yyscanner;
426 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
427
428 if (input.isEmpty()) return;
429
430 DebugLex debugLex(Debug::Lex_sqlcode, __FILE__, fileDef ? qPrint(fileDef->fileName()): nullptr);
431 yyextra->fileName = fileDef ? fileDef->fileName():"";
432
433 yyextra->code = &codeOutIntf;
434 yyextra->inputString = input.data();
435 yyextra->inputPosition = 0;
436 yyextra->currentFontClass = nullptr;
437 yyextra->insideCodeLine = false;
438 yyextra->searchCtx=searchCtx;
439
440 if (startLine!=-1)
441 yyextra->yyLineNr = startLine;
442 else
443 yyextra->yyLineNr = 1;
444
445 if (endLine!=-1)
446 yyextra->inputLines = endLine+1;
447 else
448 yyextra->inputLines = yyextra->yyLineNr + countLines(yyscanner) - 1;
449
450 yyextra->stripCodeComments = stripCodeComments;
451 yyextra->exampleBlock = isExampleBlock;
452 yyextra->exampleName = exampleName;
453 yyextra->sourceFileDef = fileDef;
454
455 if (isExampleBlock && fileDef==0)
456 {
457 // create a dummy filedef for the example
458 yyextra->exampleFileDef = createFileDef(QCString(),!exampleName.isEmpty() ? exampleName : QCString("generated"));
459 yyextra->sourceFileDef = yyextra->exampleFileDef.get();
460 }
461
462 if (yyextra->sourceFileDef)
463 {
464 setCurrentDoc(yyscanner,"l00001");
465 }
466
467 yyextra->includeCodeFragment = inlineFragment;
468 // Starts line 1 on the output
469 startCodeLine(yyscanner);
470
471 sqlcodeYYrestart( nullptr, yyscanner );
472
473 sqlcodeYYlex(yyscanner);
474
475 if (yyextra->insideCodeLine)
476 {
477 endCodeLine(yyscanner);
478 }
479 if (yyextra->exampleFileDef)
480 {
481 // delete the temporary file definition used for this example
482 yyextra->exampleFileDef.reset();
483 yyextra->sourceFileDef=nullptr;
484 }
485}
486
487//---------------------------------------------------------------------------------
488
489#include "sqlcode.l.h"
@ Lex_sqlcode
Definition debug.h:68
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
virtual bool isLinkableInProject() const =0
virtual QCString getReference() const =0
virtual QCString getOutputFileBase() const =0
virtual const QCString & name() const =0
static SearchIndexIntf searchIndex
Definition doxygen.h:124
virtual QCString fileName() const =0
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString & sprintf(const char *format,...)
Definition qcstring.cpp:29
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:172
std::unique_ptr< Private > p
Definition sqlcode.h:55
void resetCodeParserState() override
Resets the state of the code parser.
Definition sqlcode.l:401
void parseCode(OutputCodeList &codeOutIntf, const QCString &scopeName, const QCString &input, SrcLangExt, bool stripCodeComments, bool isExampleBlock, const QCString &exampleName=QCString(), const FileDef *fileDef=nullptr, int startLine=-1, int endLine=-1, bool inlineFragment=FALSE, const MemberDef *memberDef=nullptr, bool showLineNumbers=TRUE, const Definition *searchCtx=nullptr, bool collectXRefs=TRUE) override
Parses a source file or fragment with the goal to produce highlighted and cross-referenced output.
Definition sqlcode.l:408
~SQLCodeParser() override
Definition sqlcode.l:396
static void endCodeLine(yyscan_t yyscanner)
Definition code.l:2478
static void nextCodeLine(yyscan_t yyscanner)
Definition code.l:2487
static void startCodeLine(yyscan_t yyscanner)
Definition code.l:2409
static int yyread(yyscan_t yyscanner, char *buf, int max_size)
Definition code.l:3963
static int countLines(yyscan_t yyscanner)
Definition code.l:3454
static void setCurrentDoc(yyscan_t yyscanner, const QCString &anchor)
Definition code.l:2277
std::unique_ptr< FileDef > createFileDef(const QCString &p, const QCString &n, const QCString &ref, const QCString &dn)
Definition filedef.cpp:268
const char * qPrint(const char *s)
Definition qcstring.h:687
sqlcodeYY_state state
Definition sqlcode.l:384
SrcLangExt
Definition types.h:207