Doxygen
Loading...
Searching...
No Matches
defargs.l File Reference
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include "defargs.h"
#include "entry.h"
#include "util.h"
#include "arguments.h"
#include "message.h"
#include "debug.h"
#include "doxygen_lex.h"
#include "defargs.l.h"
Include dependency graph for defargs.l:

Go to the source code of this file.

Classes

struct  defargsYY_state
class  KeywordHash

Macros

#define YY_TYPEDEF_YY_SCANNER_T
#define YY_NO_INPUT   1
#define YY_NO_UNISTD_H   1
#define YY_INPUT(buf, result, max_size)
#define LEX_NO_INPUT_FILENAME
#define TOTAL_KEYWORDS   28
#define MIN_WORD_LENGTH   3
#define MAX_WORD_LENGTH   9
#define MIN_HASH_VALUE   3
#define MAX_HASH_VALUE   48

Typedefs

typedef yyguts_t * yyscan_t

Functions

static const char * stateToString (int state)
static int yyread (yyscan_t yyscanner, char *buf, int max_size)
static bool nameIsActuallyPartOfType (QCString &name)
static const char * getLexerFILE ()
int yylex (yyscan_t yyscanner)
std::unique_ptr< ArgumentList > stringToArgumentList (SrcLangExt lang, const QCString &argsString, QCString *extraTypeChars)

Detailed Description

This scanner is used to convert a string into a list of function or template arguments. Each parsed argument results in a Argument struct, that is put into an ArgumentList in declaration order. Comment blocks for arguments can also be included in the string. The argument string does not contain new-lines (except inside any comment blocks). An Argument consists of the string fields: type,name,default value, and documentation The Argument list as a whole can be pure, constant or volatile.

Examples of input strings are: 

*    "(int a,int b) const"
*    "(const char *s="hello world",int=5) = 0"
*    "<class T,class N>"
*    "(char c,const char)"
*

Note: It is not always possible to distinguish between the name and type of an argument. In case of doubt the name is added to the type, and the matchArgumentList in util.cpp is be used to further determine the correct separation.

Definition in file defargs.l.

Macro Definition Documentation

◆ LEX_NO_INPUT_FILENAME

#define LEX_NO_INPUT_FILENAME

Definition at line 117 of file defargs.l.

◆ MAX_HASH_VALUE

#define MAX_HASH_VALUE   48

Definition at line 679 of file defargs.l.

Referenced by KeywordHash::find().

◆ MAX_WORD_LENGTH

#define MAX_WORD_LENGTH   9

Definition at line 677 of file defargs.l.

◆ MIN_HASH_VALUE

#define MIN_HASH_VALUE   3

Definition at line 678 of file defargs.l.

◆ MIN_WORD_LENGTH

#define MIN_WORD_LENGTH   3

Definition at line 676 of file defargs.l.

Referenced by KeywordHash::find().

◆ TOTAL_KEYWORDS

#define TOTAL_KEYWORDS   28

Definition at line 675 of file defargs.l.

◆ YY_INPUT

#define YY_INPUT ( buf,
result,
max_size )
Value:
result=yyread(yyscanner,buf,max_size);
yyread
static int yyread(yyscan_t yyscanner, char *buf, int max_size)
Definition code.l:3992

Definition at line 113 of file defargs.l.

◆ YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 71 of file defargs.l.

◆ YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 72 of file defargs.l.

◆ YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 49 of file defargs.l.

Typedef Documentation

◆ yyscan_t

typedef yyguts_t* yyscan_t

Definition at line 51 of file defargs.l.

Function Documentation

◆ getLexerFILE()

const char * getLexerFILE ( )
inlinestatic

Definition at line 116 of file defargs.l.

116{return __FILE__;}

◆ nameIsActuallyPartOfType()

bool nameIsActuallyPartOfType ( QCString & name)
static

Definition at line 797 of file defargs.l.

798{
799 return KeywordHash::find(name.data(),name.length())!=nullptr;
KeywordHash::find
static const char * find(const char *str, size_t len)
Definition defargs.l:737
QCString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
QCString::data
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:159
800}

References QCString::data(), KeywordHash::find(), and QCString::length().

◆ stateToString()

const char * stateToString ( int state)
static

◆ stringToArgumentList()

std::unique_ptr< ArgumentList > stringToArgumentList ( SrcLangExt lang,
const QCString & argsString,
QCString * extraTypeChars )

Converts an argument string into an ArgumentList.

Parameters
[in]langlanguage of the current argument list
[in]argsStringthe list of Arguments.
[out]extraTypeCharspoint to string to which trailing characters for complex types are written to

Definition at line 809 of file defargs.l.

810{
811 std::unique_ptr<ArgumentList> al = std::make_unique<ArgumentList>();
812 if (argsString.isEmpty()) return al;
QCString::isEmpty
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:150
813
814 yyscan_t yyscanner;
815 defargsYY_state extra(argsString.data(),al,lang);
816 defargsYYlex_init_extra(&extra,&yyscanner);
yyscan_t
yyguts_t * yyscan_t
Definition code.l:24
defargsYY_state
Definition defargs.l:78
817#ifdef FLEX_DEBUG
818 defargsYYset_debug(Debug::isFlagSet(Debug::Lex_defargs)?1:0,yyscanner);
Debug::Lex_defargs
@ Lex_defargs
Definition debug.h:58
Debug::isFlagSet
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
819#endif
820 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
821 DebugLex debugLex(Debug::Lex_defargs, __FILE__, nullptr);
822
823 defargsYYrestart( nullptr, yyscanner );
824 BEGIN( Start );
825 defargsYYlex(yyscanner);
826 if (yyextra->argList->empty())
827 {
828 yyextra->argList->setNoParameters(TRUE);
829 }
830 if (extraTypeChars) *extraTypeChars=yyextra->extraTypeChars;
831 //printf("stringToArgumentList(%s) result=%s\n",argsString,qPrint(argListToString(*al)));
832 defargsYYlex_destroy(yyscanner);
833 return al;
TRUE
#define TRUE
Definition qcstring.h:37
834}

References QCString::data(), QCString::isEmpty(), Debug::isFlagSet(), Debug::Lex_defargs, and TRUE.

Referenced by addClassToContext(), ClassDefImpl::addMemberToTemplateInstance(), buildDefineList(), buildFunctionList(), anonymous_namespace{tagreader.cpp}::TagFileParser::buildMemberList(), combineDeclarationAndDefinition(), computeTemplateClassRelations(), findMembersWithSpecificName(), findTemplateInstanceRelation(), generateDEFForMember(), getDefsOld(), SymbolResolver::Private::getResolvedSymbol(), SymbolResolver::Private::getResolvedSymbolRec(), SymbolResolver::Private::getResolvedTypeRec(), MemberDefImpl::init(), ClassDefImpl::insertTemplateInstance(), and matchCanonicalTypes().

◆ yylex()

int yylex ( yyscan_t yyscanner)

Definition at line 155 of file defargs.l.

157 { BEGIN(ReadFuncArgType); }
158
159<ReadFuncArgType>{B}* {
160 yyextra->curArgTypeName+=" ";
161 }
162<ReadFuncArgType>"["[^\]]*"]" {
163 if (yyextra->curArgTypeName.stripWhiteSpace().isEmpty())
164 {
165 yyextra->curArgAttrib=yytext; // for M$-IDL
166 }
167 else // array type
168 {
169 yyextra->curArgArray+=yytext;
170 }
171 }
172<ReadFuncArgDef>"'"\\[0-7]{1,3}"'" { yyextra->curArgDefValue+=yytext; }
173<ReadFuncArgDef>"'"\\."'" { yyextra->curArgDefValue+=yytext; }
174<ReadFuncArgDef>"'"."'" { yyextra->curArgDefValue+=yytext; }
175<ReadFuncArgDef>{RAWBEGIN} { yyextra->curArgDefValue+=yytext;
176 yyextra->delimiter = extractBeginRawStringDelimiter(yytext);
177 BEGIN( CopyRawString );
178 }
extractBeginRawStringDelimiter
QCString extractBeginRawStringDelimiter(const char *rawStart)
Definition util.cpp:7451
179<ReadFuncArgDef>\" {
180 yyextra->curArgDefValue+=*yytext;
181 BEGIN( CopyArgString );
182 }
183<ReadFuncArgType>"("([^:)]+{B}*"::")*{B}*[&*\^]+{Bopt}/{ID} {
184 // function pointer as argument
185 yyextra->curArgTypeName+=yytext;
186 //yyextra->curArgTypeName=yyextra->curArgTypeName.simplifyWhiteSpace();
187 BEGIN( ReadFuncArgPtr );
188 }
189<ReadFuncArgPtr>{ID} {
190 yyextra->curArgName=yytext;
191 }
192<ReadFuncArgPtr>")"{B}*"(" { // function pointer
193 yyextra->curArgTypeName+=yytext;
194 //yyextra->curArgTypeName=yyextra->curArgTypeName.simplifyWhiteSpace();
195 yyextra->readArgContext = ReadFuncArgType;
196 yyextra->copyArgValue=&yyextra->curArgTypeName;
197 yyextra->argRoundCount=0;
198 BEGIN( CopyArgRound2 );
199 }
200<ReadFuncArgPtr>")"/{B}*"[" { // pointer to fixed size array
201 yyextra->curArgTypeName+=yytext;
202 yyextra->curArgTypeName+=yyextra->curArgName;
203 //yyextra->curArgTypeName=yyextra->curArgTypeName.simplifyWhiteSpace();
204 BEGIN( ReadFuncArgType );
205 }
206<ReadFuncArgPtr>")" { // redundant braces detected / remove them
207 int i=yyextra->curArgTypeName.findRev('(');
208 int l=static_cast<int>(yyextra->curArgTypeName.length());
209 if (i!=-1)
210 {
211 yyextra->curArgTypeName=yyextra->curArgTypeName.left(i)+
212 yyextra->curArgTypeName.right(l-i-1);
213 }
214 yyextra->curArgTypeName+=yyextra->curArgName;
215 BEGIN( ReadFuncArgType );
216 }
217<ReadFuncArgType>"<="|">="|"->"|">>"|"<<" { // handle operators in defargs
218 yyextra->curArgTypeName+=yytext;
219 }
220<ReadFuncArgType,ReadFuncArgDef>[({<\[] {
221 if (YY_START==ReadFuncArgType)
222 {
223 yyextra->curArgTypeName+=*yytext;
224 yyextra->copyArgValue=&yyextra->curArgTypeName;
225 }
226 else // YY_START==ReadFuncArgDef
227 {
228 yyextra->curArgDefValue+=*yytext;
229 yyextra->copyArgValue=&yyextra->curArgDefValue;
230 }
231 yyextra->readArgContext = YY_START;
232 if (*yytext=='(')
233 {
234 yyextra->argRoundCount=0;
235 BEGIN( CopyArgRound );
236 }
237 else if (*yytext=='[')
238 {
239 yyextra->argSquareCount=0;
240 BEGIN( CopyArgSquare );
241 }
242 else if (*yytext=='{')
243 {
244 yyextra->argCurlyCount=0;
245 BEGIN( CopyArgCurly );
246 }
247 else // yytext=='<'
248 {
249 yyextra->argSharpCount=0;
250 yyextra->argRoundCount=0;
251 BEGIN( CopyArgSharp );
252 }
253 }
254<CopyArgRound,CopyArgRound2>"(" {
255 yyextra->argRoundCount++;
256 *yyextra->copyArgValue += *yytext;
257 }
258<CopyArgRound,CopyArgRound2>")"({B}*{ID})* {
259 *yyextra->copyArgValue += yytext;
260 if (yyextra->argRoundCount>0)
261 {
262 yyextra->argRoundCount--;
263 }
264 else
265 {
266 if (YY_START==CopyArgRound2)
267 {
268 *yyextra->copyArgValue+=" "+yyextra->curArgName;
269 }
270 BEGIN( yyextra->readArgContext );
271 }
272 }
273<CopyArgRound>")"/{B}* {
274 *yyextra->copyArgValue += *yytext;
275 if (yyextra->argRoundCount>0) yyextra->argRoundCount--;
276 else BEGIN( yyextra->readArgContext );
277 }
278<CopyArgSquare>"[" {
279 yyextra->argSquareCount++;
280 *yyextra->copyArgValue += *yytext;
281 }
282<CopyArgSquare>"]"({B}*{ID})* {
283 *yyextra->copyArgValue += yytext;
284 if (yyextra->argSquareCount>0)
285 {
286 yyextra->argRoundCount--;
287 }
288 else
289 {
290 BEGIN( yyextra->readArgContext );
291 }
292 }
293<CopyArgSquare>"]"/{B}* {
294 *yyextra->copyArgValue += *yytext;
295 if (yyextra->argSquareCount>0) yyextra->argSquareCount--;
296 else BEGIN( yyextra->readArgContext );
297 }
298<CopyArgSharp>"<<" {
299 if (yyextra->argRoundCount>0)
300 {
301 // for e.g. < typename A = (i<<3) >
302 *yyextra->copyArgValue += yytext;
303 }
304 else
305 {
306 REJECT;
307 }
308 }
309<CopyArgSharp>">>" {
310 if (yyextra->argRoundCount>0)
311 {
312 // for e.g. < typename A = (i>>3) >
313 *yyextra->copyArgValue += yytext;
314 }
315 else
316 {
317 REJECT;
318 }
319 }
320<CopyArgSharp>"<" {
321 // don't count < inside (, e.g. for things like: < typename A=(i<6) >
322 if (yyextra->argRoundCount==0) yyextra->argSharpCount++;
323 *yyextra->copyArgValue += *yytext;
324 }
325<CopyArgSharp>">" {
326 *yyextra->copyArgValue += *yytext;
327 if (yyextra->argRoundCount>0 && yyextra->argSharpCount==0)
328 {
329 // don't count > inside )
330 }
331 else
332 {
333 if (yyextra->argSharpCount>0)
334 {
335 yyextra->argSharpCount--;
336 }
337 else
338 {
339 BEGIN( yyextra->readArgContext );
340 }
341 }
342 }
343<CopyArgSharp>"(" {
344 yyextra->argRoundCount++;
345 *yyextra->copyArgValue += *yytext;
346 }
347<CopyArgSharp>")" {
348 yyextra->argRoundCount--;
349 *yyextra->copyArgValue += *yytext;
350 }
351<CopyArgCurly>"{" {
352 yyextra->argCurlyCount++;
353 *yyextra->copyArgValue += *yytext;
354 }
355<CopyArgCurly>"}" {
356 *yyextra->copyArgValue += *yytext;
357 if (yyextra->argCurlyCount>0) yyextra->argCurlyCount--;
358 else BEGIN( yyextra->readArgContext );
359 }
360<CopyArgString>\\. {
361 yyextra->curArgDefValue+=yytext;
362 }
363<CopyRawString>{RAWEND} {
364 yyextra->curArgDefValue+=yytext;
365 if (extractEndRawStringDelimiter(yytext)==yyextra->delimiter)
366 {
367 BEGIN( ReadFuncArgDef );
368 }
369 }
extractEndRawStringDelimiter
QCString extractEndRawStringDelimiter(const char *rawEnd)
Definition util.cpp:7459
370<CopyArgString>\" {
371 yyextra->curArgDefValue+=*yytext;
372 BEGIN( ReadFuncArgDef );
373 }
374<ReadFuncArgType>"=" {
375 BEGIN( ReadFuncArgDef );
376 }
377<ReadFuncArgType,ReadFuncArgDef>[,)>]{B}*({CCS}[*!]|{CPPC}[/!])"<" {
378 yyextra->lastDocContext=YY_START;
379 yyextra->lastDocChar=*yytext;
380 QCString text(yytext);
381 if (text.find("//")!=-1)
382 BEGIN( ReadDocLine );
383 else
384 BEGIN( ReadDocBlock );
385 }
QCString
This is an alternative implementation of QCString.
Definition qcstring.h:101
386<ReadFuncArgType,ReadFuncArgDef>[,)>] {
387 if (*yytext==')' && yyextra->curArgTypeName.stripWhiteSpace().isEmpty())
388 {
389 yyextra->curArgTypeName+=*yytext;
390 BEGIN(FuncQual);
391 }
392 else
393 {
394 yyextra->curArgTypeName=removeRedundantWhiteSpace(yyextra->curArgTypeName);
395 yyextra->curArgDefValue=yyextra->curArgDefValue.stripWhiteSpace();
396 //printf("curArgType='%s' curArgDefVal='%s'\n",qPrint(yyextra->curArgTypeName),qPrint(yyextra->curArgDefValue));
397 int l = static_cast<int>(yyextra->curArgTypeName.length());
398 if (l>0)
399 {
400 int i=l-1;
401 while (i>=0 && (isspace((uint8_t)yyextra->curArgTypeName.at(i)) || yyextra->curArgTypeName.at(i)=='.')) i--;
402 while (i>=0 && (isId(yyextra->curArgTypeName.at(i)) || yyextra->curArgTypeName.at(i)=='$')) i--;
403 Argument a;
404 a.attrib = yyextra->curArgAttrib;
405 a.typeConstraint = yyextra->curTypeConstraint.stripWhiteSpace();
406 //printf("a->type=%s a->name=%s i=%d l=%d\n",
407 // qPrint(a->type),qPrint(a->name),i,l);
408 a.array.clear();
409 if (i==l-1 && yyextra->curArgTypeName.at(i)==')') // function argument
410 {
411 int bi=yyextra->curArgTypeName.find('(');
412 int fi=bi-1;
413 //printf("func arg fi=%d\n",fi);
414 while (fi>=0 && (isId(yyextra->curArgTypeName.at(fi)) || yyextra->curArgTypeName.at(fi)==':')) fi--;
415 if (fi>=0)
416 {
417 a.type = yyextra->curArgTypeName.left(fi+1);
418 a.name = yyextra->curArgTypeName.mid(fi+1,bi-fi-1).stripWhiteSpace();
419 a.array = yyextra->curArgTypeName.right(l-bi);
420 }
421 else
422 {
423 a.type = yyextra->curArgTypeName;
424 }
425 }
426 else if (i>=0 && yyextra->curArgTypeName.at(i)!=':')
427 { // type contains a name
428 a.type = removeRedundantWhiteSpace(yyextra->curArgTypeName.left(i+1)).stripWhiteSpace();
429 a.name = yyextra->curArgTypeName.right(l-i-1).stripWhiteSpace();
QCString::mid
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:226
QCString::stripWhiteSpace
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:245
QCString::right
QCString right(size_t len) const
Definition qcstring.h:219
QCString::left
QCString left(size_t len) const
Definition qcstring.h:214
QCString::clear
void clear()
Definition qcstring.h:169
Argument
This class contains the information about the argument of a function or template.
Definition arguments.h:27
Argument::type
QCString type
Definition arguments.h:42
Argument::name
QCString name
Definition arguments.h:44
Argument::array
QCString array
Definition arguments.h:45
Argument::typeConstraint
QCString typeConstraint
Definition arguments.h:48
Argument::attrib
QCString attrib
Definition arguments.h:41
removeRedundantWhiteSpace
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:579
isId
bool isId(int c)
Definition util.h:208
430
431 // if the type becomes a type specifier only then we make a mistake
432 // and need to correct it to avoid seeing a nameless parameter
433 // "struct A" as a parameter with type "struct" and name "A".
434 int sv=0;
435 if (a.type.startsWith("const ")) sv=6;
436 else if (a.type.startsWith("volatile ")) sv=9;
QCString::startsWith
bool startsWith(const char *s) const
Definition qcstring.h:492
437
438 if (a.type.mid(sv)=="struct" ||
439 a.type.mid(sv)=="union" ||
440 a.type.mid(sv)=="class" ||
441 a.type.mid(sv)=="typename" ||
442 a.type=="const" ||
443 a.type=="volatile" ||
444 nameIsActuallyPartOfType(a.name)
445 )
446 {
447 a.type = a.type + " " + a.name;
448 a.name.clear();
449 }
450 //printf(" --> a->type='%s' a->name='%s'\n",qPrint(a->type),qPrint(a->name));
451 }
452 else // assume only the type was specified, try to determine name later
453 {
454 a.type = removeRedundantWhiteSpace(yyextra->curArgTypeName);
455 }
456 if (!a.type.isEmpty() && a.type.at(0)=='$') // typeless PHP name?
457 {
458 a.name = a.type;
459 a.type = "";
460 }
461 a.array += removeRedundantWhiteSpace(yyextra->curArgArray);
462 //printf("array=%s\n",qPrint(a->array));
463 size_t alen = a.array.length();
464 if (alen>2 && a.array.at(0)=='(' &&
465 a.array.at(alen-1)==')') // fix-up for int *(a[10])
466 {
467 i=a.array.find('[')-1;
468 a.array = a.array.mid(1,alen-2);
469 if (i>0 && a.name.isEmpty())
470 {
471 a.name = a.array.left(i).stripWhiteSpace();
472 a.array = a.array.mid(i);
473 }
474 }
475 a.defval = yyextra->curArgDefValue;
476 //printf("a->type=%s a->name=%s a->defval=\"%s\"\n",qPrint(a->type),qPrint(a->name),qPrint(a->defval));
477 a.docs = yyextra->curArgDocs.stripWhiteSpace();
478 //printf("Argument '%s' '%s' adding docs='%s'\n",qPrint(a->type),qPrint(a->name),qPrint(a->docs));
479 yyextra->argList->push_back(a);
480 }
481 yyextra->curArgAttrib.clear();
482 yyextra->curArgTypeName.clear();
483 yyextra->curArgDefValue.clear();
484 yyextra->curArgArray.clear();
485 yyextra->curArgDocs.clear();
486 yyextra->curTypeConstraint.clear();
487 if (*yytext==')')
488 {
489 BEGIN(FuncQual);
490 //printf(">>> end of argument list\n");
491 }
492 else
493 {
494 BEGIN( ReadFuncArgType );
495 }
496 }
497 }
QCString::find
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:578
nameIsActuallyPartOfType
static bool nameIsActuallyPartOfType(QCString &name)
Definition defargs.l:797
Argument::defval
QCString defval
Definition arguments.h:46
Argument::docs
QCString docs
Definition arguments.h:47
498<ReadFuncArgType,ReadFuncArgPtr>"extends" {
499 if (yyextra->lang!=SrcLangExt::Java)
500 {
501 REJECT;
502 }
503 else
504 {
505 yyextra->curTypeConstraint.clear();
506 yyextra->lastExtendsContext=YY_START;
507 BEGIN(ReadTypeConstraint);
508 }
509 }
510<ReadFuncArgType,ReadFuncArgPtr>"$"?{ID} {
511 QCString name(yytext);
512 if (YY_START==ReadFuncArgType && yyextra->curArgArray=="[]") // Java style array
513 {
514 yyextra->curArgTypeName+=" []";
515 yyextra->curArgArray.clear();
516 }
517 //printf("resolveName '%s'->'%s'\n",yytext,qPrint(name));
518 yyextra->curArgTypeName+=name;
519 }
520<ReadFuncArgType,ReadFuncArgPtr>. {
521 yyextra->curArgTypeName+=*yytext;
522 }
523
524<ReadFuncArgDef,CopyArgString>"<="|"->"|">="|">>"|"<<" {
525 yyextra->curArgDefValue+=yytext;
526 }
527<ReadFuncArgDef,CopyArgString,CopyRawString>. {
528 yyextra->curArgDefValue+=*yytext;
529 }
530<CopyArgRound,CopyArgRound2,CopyArgSquare,CopyArgSharp,CopyArgCurly>{ID} {
531 *yyextra->copyArgValue+=yytext;
532 }
533<CopyArgRound,CopyArgRound2,CopyArgSquare,CopyArgSharp,CopyArgCurly>. {
534 *yyextra->copyArgValue += *yytext;
535 }
536<ReadTypeConstraint>[,)>] {
537 unput(*yytext);
538 BEGIN(yyextra->lastExtendsContext);
539 }
540<ReadTypeConstraint>. {
541 yyextra->curTypeConstraint+=yytext;
542 }
543<ReadTypeConstraint>\n {
544 yyextra->curTypeConstraint+=' ';
545 }
546<FuncQual>"const" {
547 yyextra->argList->setConstSpecifier(TRUE);
548 }
549<FuncQual>"volatile" {
550 yyextra->argList->setVolatileSpecifier(TRUE);
551 }
552<FuncQual>"override" {
553 }
554<FuncQual>"&" {
555 yyextra->argList->setRefQualifier(RefQualifierType::LValue);
556 }
557<FuncQual>"&&" {
558 yyextra->argList->setRefQualifier(RefQualifierType::RValue);
559 }
560<FuncQual,TrailingReturn>"="{B}*"0" {
561 yyextra->argList->setPureSpecifier(TRUE);
562 BEGIN(FuncQual);
563 }
564<FuncQual>"->" { // C++11 trailing return type
565 yyextra->argList->setTrailingReturnType(QCString(" -> "));
566 BEGIN(TrailingReturn);
567 }
568<TrailingReturn>{B}/("final"|"override"){B}* {
569 unput(*yytext);
570 BEGIN(FuncQual);
571 }
572<TrailingReturn>. {
573 yyextra->argList->setTrailingReturnType(yyextra->argList->trailingReturnType()+yytext);
574 }
575<TrailingReturn>\n {
576 yyextra->argList->setTrailingReturnType(yyextra->argList->trailingReturnType()+yytext);
577 }
578<FuncQual>")"{B}*"["[^]]*"]" { // for functions returning a pointer to an array,
579 // i.e. ")[]" in "int (*f(int))[4]" with argsString="(int))[4]"
580 yyextra->extraTypeChars=yytext;
581 }
582<ReadDocBlock>[^\*\n]+ {
583 yyextra->curArgDocs+=yytext;
584 }
585<ReadDocLine>[^\n]+ {
586 yyextra->curArgDocs+=yytext;
587 }
588<ReadDocBlock>{CCE} {
589 if (yyextra->lastDocChar!=0)
590 unput(yyextra->lastDocChar);
591 BEGIN(yyextra->lastDocContext);
592 }
593<ReadDocLine>\n {
594 if (yyextra->lastDocChar!=0)
595 unput(yyextra->lastDocChar);
596 BEGIN(yyextra->lastDocContext);
597 }
598<ReadDocBlock>\n {
599 yyextra->curArgDocs+=*yytext;
600 }
601<ReadDocBlock>. {
602 yyextra->curArgDocs+=*yytext;
603 }
604<*>({CCS}[*!]|{CPPC}[/!])("<"?) {
605 yyextra->lastDocContext=YY_START;
606 yyextra->lastDocChar=0;
607 if (yytext[1]=='/')
608 BEGIN( ReadDocLine );
609 else
610 BEGIN( ReadDocBlock );
611 }
612<*>\n
613<*>.
614
615%%

◆ yyread()

int yyread ( yyscan_t yyscanner,
char * buf,
int max_size )
static

Definition at line 620 of file defargs.l.

621{
622 struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
623 int c=0;
624 while( c < max_size && yyextra->inputString[yyextra->inputPosition] )
625 {
626 *buf = yyextra->inputString[yyextra->inputPosition++] ;
627 c++; buf++;
628 }
629 return c;
630}