sqlcode.l File Reference

#include <stdint.h>
#include <stdio.h>
#include "sqlcode.h"
#include "entry.h"
#include "doxygen.h"
#include "outputlist.h"
#include "util.h"
#include "membername.h"
#include "searchindex.h"
#include "config.h"
#include "filedef.h"
#include "tooltip.h"
#include "message.h"
#include "debug.h"
#include "doxygen_lex.h"
#include "sqlcode.l.h"

Include dependency graph for sqlcode.l:

Go to the source code of this file.

Classes
struct	sqlcodeYY_state
struct	SQLCodeParser::Private

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

Typedefs
typedef yyguts_t *	yyscan_t

Functions
static const char *	stateToString (int state)
static void	setCurrentDoc (yyscan_t yyscanner, const DString &anchor)
static void	startCodeLine (yyscan_t yyscanner)
static void	endFontClass (yyscan_t yyscanner)
static void	endCodeLine (yyscan_t yyscanner)
static void	nextCodeLine (yyscan_t yyscanner)
static void	codifyLines (yyscan_t yyscanner, const char *text)
static void	startFontClass (yyscan_t yyscanner, const char *s)
static int	countLines (yyscan_t yyscanner)
static int	yyread (yyscan_t yyscanner, char *buf, int max_size)
static const char *	getLexerFILE ()
int	yylex (yyscan_t yyscanner)

Macro Definition Documentation

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size )

Value:

result=yyread(yyscanner,buf,max_size);

Definition at line 90 of file sqlcode.l.

YY_NEVER_INTERACTIVE

#define YY_NEVER_INTERACTIVE   1

Definition at line 48 of file sqlcode.l.

YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 49 of file sqlcode.l.

YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 50 of file sqlcode.l.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 25 of file sqlcode.l.

Typedef Documentation

yyscan_t

typedef yyguts_t* yyscan_t

Definition at line 27 of file sqlcode.l.

Function Documentation

codifyLines()

void codifyLines ( yyscan_t yyscanner, const char * text )

static

Definition at line 311 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  const char *p=text,*sp=p;
  char c;
  bool done=false;
  while (!done)
  {
    sp=p;
    while ((c=*p++) && c!='\n') { }
    if (c=='\n')
    {
      yyextra->yyLineNr++;
      size_t l = static_cast<size_t>(p-sp-1);
      yyextra->code->codify(DString(sp,l));
      nextCodeLine(yyscanner);
    }
    else
    {
      yyextra->code->codify(sp);
      done=true;
    }
  }
}

References codifyLines(), DString::DString(), and nextCodeLine().

Referenced by codifyLines(), and stateToString().

countLines()

int countLines ( yyscan_t yyscanner )

static

counts the number of lines in the input

Definition at line 345 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  const char *p=yyextra->inputString;
  char c;
  int count=1;
  while ((c=*p))
  {
    p++ ;
    if (c=='\n') count++;
  }
  if (p>yyextra->inputString && *(p-1)!='\n')
  { // last line does not end with a \n, so we add an extra
    // line and explicitly terminate the line after parsing.
    count++;
  }
  return count;
}

References countLines().

Referenced by countLines(), SQLCodeParser::parseCode(), and stateToString().

endCodeLine()

void endCodeLine ( yyscan_t yyscanner )

static

Definition at line 288 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  endFontClass(yyscanner);
  yyextra->code->endCodeLine();
  yyextra->insideCodeLine=false;
}

References endCodeLine(), and endFontClass().

Referenced by endCodeLine(), nextCodeLine(), SQLCodeParser::parseCode(), and stateToString().

endFontClass()

void endFontClass ( yyscan_t yyscanner )

static

Definition at line 278 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->currentFontClass)
  {
    yyextra->code->endFontClass();
    yyextra->currentFontClass=0;
  }
}

References endFontClass().

Referenced by endCodeLine(), endFontClass(), startFontClass(), and stateToString().

getLexerFILE()

const char * getLexerFILE ( )

inlinestatic

Definition at line 93 of file sqlcode.l.

{return __FILE__;}

References getLexerFILE().

nextCodeLine()

void nextCodeLine ( yyscan_t yyscanner )

static

Definition at line 296 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  const char *fc = yyextra->currentFontClass;
  if (yyextra->insideCodeLine)
  {
    endCodeLine(yyscanner);
  }
  if (yyextra->yyLineNr<yyextra->inputLines)
  {
    yyextra->currentFontClass = fc;
    startCodeLine(yyscanner);
  }
}

References endCodeLine(), nextCodeLine(), and startCodeLine().

Referenced by codifyLines(), nextCodeLine(), and stateToString().

setCurrentDoc()

void setCurrentDoc ( yyscan_t yyscanner, const DString & anchor )

static

Definition at line 211 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (Doxygen::searchIndex.enabled())
  {
    if (yyextra->searchCtx)
    {
      Doxygen::searchIndex.setCurrentDoc(yyextra->searchCtx,yyextra->searchCtx->anchor(),false);
    }
    else
    {
      Doxygen::searchIndex.setCurrentDoc(yyextra->sourceFileDef,anchor,true);
    }
  }
}

References Doxygen::searchIndex, SearchIndexIntf::setCurrentDoc(), and setCurrentDoc().

Referenced by SQLCodeParser::parseCode(), setCurrentDoc(), startCodeLine(), and stateToString().

startCodeLine()

void startCodeLine ( yyscan_t yyscanner )

static

start a new line of code, inserting a line number if yyextra->sourceFileDef is true. If a definition starts at the current line, then the line number is linked to the documentation of that definition.

Definition at line 231 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  if (yyextra->sourceFileDef && yyextra->lineNumbers)
  {
    const Definition *d = yyextra->sourceFileDef->getSourceDefinition(yyextra->yyLineNr);
 
    if (!yyextra->includeCodeFragment && d && d->isLinkableInProject())
    {
      yyextra->currentDefinition = d;
      yyextra->currentMemberDef = yyextra->sourceFileDef->getSourceMember(yyextra->yyLineNr);
      yyextra->classScope = d->name();
      DString lineAnchor;
      lineAnchor.sprintf("l%05d",yyextra->yyLineNr);
      if (yyextra->currentMemberDef)
      {
        yyextra->code->writeLineNumber(yyextra->currentMemberDef->getReference(),
                            yyextra->currentMemberDef->getOutputFileBase(),
                            yyextra->currentMemberDef->anchor(),yyextra->yyLineNr,
                            !yyextra->includeCodeFragment);
        setCurrentDoc(yyscanner,lineAnchor);
      }
      else
      {
        yyextra->code->writeLineNumber(d->getReference(),
                            d->getOutputFileBase(),
                            DString(),yyextra->yyLineNr,
                            !yyextra->includeCodeFragment);
        setCurrentDoc(yyscanner,lineAnchor);
      }
    }
    else
    {
      yyextra->code->writeLineNumber(DString(),DString(),DString(),yyextra->yyLineNr,
                                     !yyextra->includeCodeFragment);
    }
  }
 
  yyextra->code->startCodeLine(yyextra->yyLineNr);
  yyextra->insideCodeLine=true;
 
  if (yyextra->currentFontClass)
  {
    yyextra->code->startFontClass(yyextra->currentFontClass);
  }
}

References DString::DString(), Definition::getOutputFileBase(), Definition::getReference(), Definition::isLinkableInProject(), Definition::name(), setCurrentDoc(), DString::sprintf(), and startCodeLine().

Referenced by nextCodeLine(), SQLCodeParser::parseCode(), startCodeLine(), and stateToString().

startFontClass()

void startFontClass ( yyscan_t yyscanner, const char * s )

static

Definition at line 336 of file sqlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  endFontClass(yyscanner);
  yyextra->code->startFontClass(s);
  yyextra->currentFontClass=s;
}

References endFontClass(), and startFontClass().

Referenced by startFontClass(), and stateToString().

stateToString()

const char * stateToString ( int state )

static

References codifyLines(), countLines(), endCodeLine(), endFontClass(), nextCodeLine(), setCurrentDoc(), startCodeLine(), startFontClass(), stateToString(), and yyread().

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 134 of file sqlcode.l.

{literals}          {
                        startFontClass(yyscanner,"stringliteral");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
 
{keyword}           {
                        startFontClass(yyscanner,"keyword");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{flowkeyword}       {
                        startFontClass(yyscanner,"keywordflow");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{typekeyword}       {
                        startFontClass(yyscanner,"keywordtype");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{variable}          {
                        startFontClass(yyscanner,"preprocessor");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{simplecomment}     {
                        startFontClass(yyscanner,"comment");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{commentopen}       {
                        startFontClass(yyscanner,"comment");
                        codifyLines(yyscanner,yytext);
                        BEGIN(COMMENT);
                    }
 
<COMMENT>.          {
                        codifyLines(yyscanner,yytext);
 
                    }
<COMMENT>{nl}       {
                        codifyLines(yyscanner,yytext);
                    }
 
<COMMENT>{commentclose} {
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                        BEGIN(INITIAL);
                    }
 
{idchar}            {
                        codifyLines(yyscanner,yytext);
                    }
 
{nl}                {
                        codifyLines(yyscanner,yytext);
                    }
 
[\x80-\xFF]*        { // keep utf8 characters together...
                        codifyLines(yyscanner,yytext);
                    }
.                   {
                        codifyLines(yyscanner,yytext);
                    }
 
%%

yyread()

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

static

Definition at line 364 of file sqlcode.l.

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

References yyread().