xmlcode.l File Reference

#include <stdint.h>
#include <stdio.h>
#include "xmlcode.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 "xmlcode.l.h"

Include dependency graph for xmlcode.l:

Go to the source code of this file.

Classes
struct	xmlcodeYY_state
struct	XMLCodeParser::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	codify (yyscan_t yyscanner, const char *text)
static void	setCurrentDoc (yyscan_t yyscanner, const QCString &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 106 of file xmlcode.l.

YY_NEVER_INTERACTIVE

#define YY_NEVER_INTERACTIVE   1

Definition at line 53 of file xmlcode.l.

YY_NO_INPUT

#define YY_NO_INPUT   1

Definition at line 54 of file xmlcode.l.

YY_NO_UNISTD_H

#define YY_NO_UNISTD_H   1

Definition at line 55 of file xmlcode.l.

YY_TYPEDEF_YY_SCANNER_T

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 30 of file xmlcode.l.

Typedef Documentation

yyscan_t

typedef yyguts_t* yyscan_t

Definition at line 32 of file xmlcode.l.

Function Documentation

codify()

void codify ( yyscan_t yyscanner, const char * text )

static

Definition at line 227 of file xmlcode.l.

{
  struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;
  yyextra->code->codify(text);
}

codifyLines()

void codifyLines ( yyscan_t yyscanner, const char * text )

static

Definition at line 334 of file xmlcode.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(QCString(sp,l));
      nextCodeLine(yyscanner);
    }
    else
    {
      yyextra->code->codify(sp);
      done=true;
    }
  }
}

References nextCodeLine().

countLines()

int countLines ( yyscan_t yyscanner )

static

counts the number of lines in the input

Definition at line 368 of file xmlcode.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;
}

endCodeLine()

void endCodeLine ( yyscan_t yyscanner )

static

Definition at line 311 of file xmlcode.l.

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

endFontClass()

void endFontClass ( yyscan_t yyscanner )

static

Definition at line 301 of file xmlcode.l.

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

getLexerFILE()

const char * getLexerFILE ( )

inlinestatic

Definition at line 109 of file xmlcode.l.

{return __FILE__;}

nextCodeLine()

void nextCodeLine ( yyscan_t yyscanner )

static

Definition at line 319 of file xmlcode.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().

setCurrentDoc()

void setCurrentDoc ( yyscan_t yyscanner, const QCString & anchor )

static

Definition at line 233 of file xmlcode.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.

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 253 of file xmlcode.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->insideBody = false;
      yyextra->classScope = d->name();
      QCString 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(),
                            QCString(),yyextra->yyLineNr,
                            !yyextra->includeCodeFragment);
        setCurrentDoc(yyscanner,lineAnchor);
      }
    }
    else
    {
      yyextra->code->writeLineNumber(QCString(),QCString(),QCString(),yyextra->yyLineNr,
                                     !yyextra->includeCodeFragment);
    }
  }
 
  yyextra->code->startCodeLine(yyextra->yyLineNr);
  yyextra->insideCodeLine = true;
 
  if (yyextra->currentFontClass)
  {
    yyextra->code->startFontClass(yyextra->currentFontClass);
  }
}

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

startFontClass()

void startFontClass ( yyscan_t yyscanner, const char * s )

static

Definition at line 359 of file xmlcode.l.

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

stateToString()

const char * stateToString ( int state )

static

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 129 of file xmlcode.l.

         {ws}       {
                        codifyLines(yyscanner,yytext);
                    }
<INITIAL>"/"        {
                        endFontClass(yyscanner);
                        codify(yyscanner,yytext);
                    }
<INITIAL>"="        {
                        endFontClass(yyscanner);
                        codify(yyscanner,yytext);
                    }
<INITIAL>{close}    {
                        endFontClass(yyscanner);
                        codify(yyscanner,yytext);
                    }
<INITIAL>{name}     {
                        startFontClass(yyscanner,"keyword");
                        codify(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
<INITIAL>{string}   {
                        startFontClass(yyscanner,"stringliteral");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
{cdata}             {
                        startFontClass(yyscanner,"xmlcdata");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
 
{open}{ws}?{name}   {
                        // Write the < in a different color
                        char openBracket[] = { yytext[0], '\0' };
                        codify(yyscanner,openBracket);
 
                        // Then write the rest
                        yytext++;
                        startFontClass(yyscanner,"keywordtype");
                        codify(yyscanner,yytext);
                        endFontClass(yyscanner);
 
                        BEGIN(INITIAL);
                    }
{open}{ws}?"/"{name} {
                        // Write the "</" in a different color
                        char closeBracket[] = { yytext[0], yytext[1], '\0' };
                        endFontClass(yyscanner);
                        codify(yyscanner,closeBracket);
 
                        // Then write the rest
                        yytext++; // skip the '<'
                        yytext++; // skip the '/'
                        startFontClass(yyscanner,"keywordtype");
                        codify(yyscanner,yytext);
                        endFontClass(yyscanner);
 
                        BEGIN(INITIAL);
                    }
{comment}           {
                        // Strip off the extra '!'
                        // yytext++; // <
                        // *yytext = '<'; // replace '!' with '<'
 
                        startFontClass(yyscanner,"comment");
                        codifyLines(yyscanner,yytext);
                        endFontClass(yyscanner);
                    }
{nl}                {
                        codifyLines(yyscanner,yytext);
                    }
 
.                   {
                        //printf("!ERROR(%c)\n", *yytext);
                        codifyLines(yyscanner,yytext);
                    }
 
%%

yyread()

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

static

Definition at line 212 of file xmlcode.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;
}