declinfo.l File Reference

#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include <ctype.h>
#include "declinfo.h"
#include "util.h"
#include "message.h"
#include "types.h"
#include "debug.h"
#include "doxygen_lex.h"
#include "declinfo.l.h"

Include dependency graph for declinfo.l:

Go to the source code of this file.

Classes
struct	declinfoYY_state

Macros
#define	YY_TYPEDEF_YY_SCANNER_T
#define	YY_NO_INPUT   1
#define	YY_NO_UNISTD_H   1
#define	YY_NEVER_INTERACTIVE   1
#define	YY_INPUT(buf, result, max_size)
#define	LEX_NO_INPUT_FILENAME

Typedefs
typedef yyguts_t *	yyscan_t

Functions
static const char *	stateToString (int state)
static void	addType (yyscan_t yyscanner)
static void	addTypeName (yyscan_t yyscanner)
static int	yyread (char *buf, int max_size, yyscan_t yyscanner)
static const char *	getLexerFILE ()
int	yylex (yyscan_t yyscanner)
void	parseFuncDecl (const QCString &decl, const SrcLangExt lang, QCString &cl, QCString &t, QCString &n, QCString &a, QCString &ftl, QCString &exc)

Variables
static yyscan_t	g_yyscanner
static struct declinfoYY_state	g_declinfo_extra

Macro Definition Documentation

LEX_NO_INPUT_FILENAME

#define LEX_NO_INPUT_FILENAME

Definition at line 89 of file declinfo.l.

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size )

Value:

result=yyread(buf,max_size,yyscanner);

Definition at line 85 of file declinfo.l.

YY_NEVER_INTERACTIVE

#define YY_NEVER_INTERACTIVE   1

Definition at line 49 of file declinfo.l.

YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 47 of file declinfo.l.

YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 48 of file declinfo.l.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 26 of file declinfo.l.

Typedef Documentation

yyscan_t

typedef yyguts_t* yyscan_t

Definition at line 28 of file declinfo.l.

Function Documentation

addType()

static void addType ( yyscan_t yyscanner )

static

Definition at line 280 of file declinfo.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  //printf("addType() yyextra->type='%s' yyextra->scope='%s' yyextra->name='%s'\n",
  //       qPrint(yyextra->type),qPrint(yyextra->scope),qPrint(yyextra->name));
  if (yyextra->name.isEmpty() && yyextra->scope.isEmpty()) return;
  if (!yyextra->type.isEmpty()) yyextra->type+=" ";
  if (!yyextra->scope.isEmpty()) yyextra->type+=yyextra->scope+"::";
  yyextra->type+=yyextra->name;
  yyextra->scope.clear();
  yyextra->name.clear();
}

addTypeName()

static void addTypeName ( yyscan_t yyscanner )

static

Definition at line 293 of file declinfo.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  //printf("addTypeName() yyextra->type='%s' yyextra->scope='%s' yyextra->name='%s'\n",
  //       qPrint(yyextra->type),qPrint(yyextra->scope),qPrint(yyextra->name));
  if (yyextra->name.isEmpty() || 
      yyextra->name.at(yyextra->name.length()-1)==':')  // end of Objective-C keyword => append to yyextra->name not yyextra->type
  {
    return;
  }
  if (!yyextra->type.isEmpty()) yyextra->type+=' ';
  yyextra->type+=yyextra->name;
  yyextra->name.clear();
}

getLexerFILE()

static const char * getLexerFILE ( )

inlinestatic

Definition at line 88 of file declinfo.l.

{return __FILE__;}

parseFuncDecl()

void parseFuncDecl	(	const QCString &	decl,
		const SrcLangExt	lang,
		QCString &	cl,
		QCString &	t,
		QCString &	n,
		QCString &	a,
		QCString &	ftl,
		QCString &	exc )

Definition at line 325 of file declinfo.l.

{
  if (decl.isEmpty())
  {
    return;
  }
  declinfoYYlex_init_extra(&g_declinfo_extra, &g_yyscanner);
  struct yyguts_t *yyg = (struct yyguts_t*)g_yyscanner;
 
#ifdef FLEX_DEBUG
  declinfoYYset_debug(Debug::isFlagSet(Debug::Lex_declinfo)?1:0,g_yyscanner);
#endif
 
  DebugLex debugLex(Debug::Lex_declinfo,__FILE__, NULL);
  yyextra->inputString   = decl.data();
  //printf("Input='%s'\n",yyextra->inputString);
  yyextra->inputPosition      = 0;
  yyextra->classTempListFound = FALSE;
  yyextra->funcTempListFound  = FALSE;
  yyextra->insideObjC = lang==SrcLangExt::ObjC;
  yyextra->insidePHP  = lang==SrcLangExt::PHP;
  yyextra->insidePython  = lang==SrcLangExt::Python;
  yyextra->scope.clear();
  yyextra->className.clear();
  yyextra->classTempList.clear();
  yyextra->funcTempList.clear();
  yyextra->name.clear();
  yyextra->type.clear();
  yyextra->args.clear();
  yyextra->exceptionString.clear();
  // first we try to find the yyextra->type, yyextra->scope, yyextra->name and arguments
  declinfoYYrestart( yyin, g_yyscanner );
  BEGIN( Start );
  declinfoYYlex(g_yyscanner);
 
  //printf("yyextra->type='%s' class='%s' yyextra->name='%s' yyextra->args='%s'\n",
  //        qPrint(yyextra->type),qPrint(yyextra->scope),qPrint(yyextra->name),qPrint(yyextra->args));
 
  int nb = yyextra->name.findRev('[');
  if (nb!=-1 && yyextra->args.isEmpty()) // correct for [] in yyextra->name ambiguity (due to Java return yyextra->type allowing [])
  {
    yyextra->args.prepend(yyextra->name.right(yyextra->name.length()-nb));
    yyextra->name=yyextra->name.left(nb);
  }
 
  cl=yyextra->scope;
  n=removeRedundantWhiteSpace(yyextra->name);
  int il=n.find('<'), ir=n.findRev('>');
  if (il!=-1 && ir!=-1 && n.at(il+1)!='=')
    // prevent <=>
    // TODO: handle cases like where n="operator<< <T>" 
  {
    ftl=removeRedundantWhiteSpace(n.right(n.length()-il));
    n=n.left(il);
  }
  
  //ctl=yyextra->classTempList.copy();
  //ftl=yyextra->funcTempList.copy();
  t=removeRedundantWhiteSpace(yyextra->type);
  a=removeRedundantWhiteSpace(yyextra->args);
  exc=removeRedundantWhiteSpace(yyextra->exceptionString);
  
  if (!t.isEmpty() && !t.startsWith("decltype") && t.at(t.length()-1)==')') // for function pointers
  {
    a.prepend(")");
    t=t.left(t.length()-1);
  }
  //printf("yyextra->type='%s' class='%s' yyextra->name='%s' yyextra->args='%s'\n",
  //        qPrint(t),qPrint(cl),qPrint(n),qPrint(a));
 
  declinfoYYlex_destroy(g_yyscanner);
  return;
}

References QCString::at(), QCString::data(), FALSE, QCString::find(), QCString::findRev(), g_declinfo_extra, g_yyscanner, QCString::isEmpty(), Debug::isFlagSet(), QCString::left(), QCString::length(), Debug::Lex_declinfo, ObjC, PHP, QCString::prepend(), Python, removeRedundantWhiteSpace(), QCString::right(), and QCString::startsWith().

Referenced by findMember().

stateToString()

static const char * stateToString ( int state )

static

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 104 of file declinfo.l.

                   {B}*"["{B}*"]")*     { // operator rule must be before {ID} rule
                                  yyextra->name += yytext;
                                  BEGIN(Operator);
                                }
<Start>{ID}({B}*"*")?{B}*"("{B}*"^"{B}*")"{B}*"(" { // Objective-C 2.0 block return type
                                  if (!yyextra->insideObjC) 
                                  {
                                    REJECT;
                                  }
                                  else
                                  {
                                    addType(yyscanner);
                                    yyextra->type += yytext;
                                  }
                                }
<Start>{ID}{B}*"("{B}*{ID}{B}*")" { // Objective-C class categories
                                  if (!yyextra->insideObjC) 
                                  {
                                    REJECT;
                                  }
                                  else 
                                  {
                                    yyextra->name += yytext;
                                  }
                                }
<Start>([~!]{B}*)?{ID}{B}*"["{B}*"]" { // PHP
                                  if (!yyextra->insidePHP)
                                  {
                                    REJECT;
                                  }
                                  addTypeName(yyscanner);
                                  yyextra->name += removeRedundantWhiteSpace(QCString(yytext));
                                }
<Start>"anonymous_namespace{"[^}]+"}" { // anonymous namespace
                                  if (!yyextra->scope.isEmpty())
                                  {
                                    yyextra->scope+=QCString("::")+yytext;
                                  }
                                  else
                                  {
                                    yyextra->scope = yytext;
                                  }
                                }
<Start>([~!]{B}*)?{ID}/({B}*"["{B}*"]")* { // the []'s are for Java, 
                                        // the / was add to deal with multi-
                                        // dimensional C++ arrays like A[][15]
                                        // the leading ~ is for a destructor
                                        // the leading ! is for a C++/CLI finalizer (see bug 456475 and 635198)
                                  addTypeName(yyscanner);
                                  yyextra->name += removeRedundantWhiteSpace(QCString(yytext));
                                }
<Start>{B}*"::"{B}*             { // found a yyextra->scope specifier
                                  if (!yyextra->scope.isEmpty() && !yyextra->scope.endsWith("::"))
                                  {
                                    if (!yyextra->name.isEmpty()) yyextra->scope+="::"+yyextra->name; // add yyextra->name to yyextra->scope
                                  }
                                  else
                                  {
                                    yyextra->scope = yyextra->name; // yyextra->scope becomes yyextra->name
                                  }
                                  yyextra->name.clear();
                                }
<Start>{B}*":"                  { // Objective-C argument separator
                                  yyextra->name+=yytext;
                                }
<Start>[*&]+                    {
                                  addType(yyscanner);
                                  yyextra->type+=yytext;
                                }
<Start>{B}+                     {
                                  addType(yyscanner);
                                }
<Start>{B}*"("({ID}"::")*{B}*[&*]({B}*("const"|"volatile"){B}+)?        {
                                  if (yyextra->insidePHP) REJECT;
                                  if (yyextra->insidePython) REJECT;
                                  addType(yyscanner);
                                  QCString text(yytext);
                                  yyextra->type+=text.stripWhiteSpace();
                                }
<Start>{B}*")"                  {
                                  yyextra->type+=")";
                                }
<Start>{B}*"decltype"/{B}*"("   {
                                          yyextra->roundCount=0;
                                          yyextra->type="decltype";
                                          BEGIN(DeclType);
                                        }
<DeclType>{B}*"("       {
                                                ++yyextra->roundCount;
                                                yyextra->type+="(";
                                        }
<DeclType>{B}*")"       {
                                                yyextra->type+=")";
                                                if (--yyextra->roundCount == 0) {
                                                        BEGIN(Start);
                                                }
                                        }
<DeclType>.     {
                                                yyextra->type+=yytext;
                                        }
<Start>{B}*"("                  { // TODO: function pointers
                                                yyextra->args+="(";
                                                BEGIN(ReadArgs);
                                        }
<Start>{B}*"["                  {
                                  yyextra->args+="[";
                                  BEGIN(ReadArgs);
                                }
<Start>{B}*"<"                  {
                                  yyextra->name+="<";
                                  yyextra->sharpCount=0;
                                  yyextra->roundCount=0;
                                  BEGIN(Template);
                                }
<Template>"<<"                  { yyextra->name+="<<"; }
<Template>">>"                  { yyextra->name+=">>"; }
<Template>"("                   { yyextra->name+="(";
                                  yyextra->roundCount++;
                                }
<Template>")"                   { yyextra->name+=")";
                                  if (yyextra->roundCount>0)
                                  {
                                    yyextra->roundCount--;
                                  }
                                }
<Template>"<"                   {
                                  yyextra->name+="<";
                                  if (yyextra->roundCount==0)
                                  {
                                    yyextra->sharpCount++;
                                  }
                                }
<Template>">"                   {
                                  yyextra->name+=">";
                                  if (yyextra->roundCount==0)
                                  {
                                    if (yyextra->sharpCount)
                                      --yyextra->sharpCount;
                                    else
                                    {
                                      BEGIN(Start);
                                    }
                                  }
                                }
<Template>.                     {
                                  yyextra->name+=*yytext;
                                }
<Operator>{B}*"("{B}*")"{B}*"<>"{Bopt}/"("      {
                                  yyextra->name+="() <>";
                                  BEGIN(ReadArgs);
                                }
<Operator>{B}*"("{B}*")"{Bopt}/"("      {
                                  yyextra->name+="()";
                                  BEGIN(ReadArgs);
                                }
<Operator>[^(]*{B}*("<>"{B}*)?/"(" {
                                  yyextra->name+=yytext;
                                  BEGIN(ReadArgs);
                                }
<ReadArgs>"throw"{B}*"("        {
                                  yyextra->exceptionString="throw(";
                                  BEGIN(ReadExceptions);
                                }
<ReadArgs>.                     {
                                  yyextra->args+=*yytext;
                                }
<ReadExceptions>.               {
                                  yyextra->exceptionString+=*yytext;
                                }
<*>.
<*>\n
 
%%

yyread()

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

static

Definition at line 308 of file declinfo.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  int c=0;
  while( c < max_size && yyextra->inputString[yyextra->inputPosition] )
  {
    *buf = yyextra->inputString[yyextra->inputPosition++] ;
    c++; buf++;
  }
  return c;
}

Variable Documentation

g_declinfo_extra

struct declinfoYY_state g_declinfo_extra

static

Definition at line 323 of file declinfo.l.

Referenced by parseFuncDecl().

g_yyscanner

yyscan_t g_yyscanner

static

Definition at line 322 of file declinfo.l.

Referenced by parseFuncDecl().