flex_scanner.cpp File Reference

#include <iostream>
#include <errno.h>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <FlexLexer.h>
#include <vector>
#include <string>
#include "scanner.h"

Include dependency graph for flex_scanner.cpp:

Go to the source code of this file.

Classes
struct	yy_buffer_state
struct	yy_trans_info

Namespaces
	SlamParser

Macros
#define	YY_INT_ALIGNED   short int
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   35
#define	FLEX_BETA
#define	yyFlexLexer   SlamFlexLexer
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE   yyrestart( yyin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	YY_LESS_LINENO(n)
#define	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_TYPEDEF_YY_SIZE_T
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	yy_new_buffer   yy_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	yytext_ptr   yytext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   15
#define	YY_END_OF_BUFFER   16
#define	REJECT   reject_used_but_not_detected
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	yyterminate()   return token::END
#define	YY_NO_UNISTD_H
#define	YY_USER_ACTION   yylloc->columns(yyleng);
#define	INITIAL   0
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   LexerOutput( yytext, yyleng )
#define	YY_INPUT(buf, result, max_size)
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   LexerError( msg )
#define	YY_BREAK   break;
#define	YY_RULE_SETUP   YY_USER_ACTION
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef SlamParser::Parser::token	token
typedef SlamParser::Parser::token_type	token_type

Functions
void *	Slamalloc (yy_size_t)
void *	Slamrealloc (void *, yy_size_t)
void	Slamfree (void *)
yylloc	step ()
	if (!(yy_init))
	while (1)
int	isatty (int)

Variables
int	yyleng
static yyconst flex_int16_t	yy_accept [77]
static yyconst flex_int32_t	yy_ec [256]
static yyconst flex_int32_t	yy_meta [47]
static yyconst flex_int16_t	yy_base [78]
static yyconst flex_int16_t	yy_def [78]
static yyconst flex_int16_t	yy_nxt [220]
static yyconst flex_int16_t	yy_chk [220]
	YY_DECL
char *	yy_cp
char *	yy_bp
int	yy_act

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 138 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_pop_state(), and yyFlexLexer::yy_push_state().

#define ECHO   LexerOutput( yytext, yyleng )

Definition at line 555 of file flex_scanner.cpp.

Referenced by while().

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 179 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_next_buffer(), and yyFlexLexer::yyinput().

#define EOB_ACT_END_OF_FILE   1

Definition at line 180 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_next_buffer(), and yyFlexLexer::yyinput().

#define EOB_ACT_LAST_MATCH   2

Definition at line 181 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_next_buffer(), and yyFlexLexer::yyinput().

#define FLEX_BETA

Definition at line 14 of file flex_scanner.cpp.

#define FLEX_SCANNER

Definition at line 9 of file flex_scanner.cpp.

#define FLEXINT_H

Definition at line 34 of file flex_scanner.cpp.

#define INITIAL   0

Definition at line 517 of file flex_scanner.cpp.

Referenced by while().

#define INT16_MAX   (32767)

Definition at line 76 of file flex_scanner.cpp.

#define INT16_MIN   (-32767-1)

Definition at line 67 of file flex_scanner.cpp.

#define INT32_MAX   (2147483647)

Definition at line 79 of file flex_scanner.cpp.

#define INT32_MIN   (-2147483647-1)

Definition at line 70 of file flex_scanner.cpp.

#define INT8_MAX   (127)

Definition at line 73 of file flex_scanner.cpp.

#define INT8_MIN   (-128)

Definition at line 64 of file flex_scanner.cpp.

#define REJECT   reject_used_but_not_detected

Definition at line 478 of file flex_scanner.cpp.

#define UINT16_MAX   (65535U)

Definition at line 85 of file flex_scanner.cpp.

#define UINT32_MAX   (4294967295U)

Definition at line 88 of file flex_scanner.cpp.

#define UINT8_MAX   (255U)

Definition at line 82 of file flex_scanner.cpp.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 199 of file flex_scanner.cpp.

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 313 of file flex_scanner.cpp.

#define YY_BREAK   break;

Definition at line 606 of file flex_scanner.cpp.

Referenced by while().

#define YY_BUF_SIZE   16384

Definition at line 164 of file flex_scanner.cpp.

Referenced by if(), yyFlexLexer::switch_streams(), and yyFlexLexer::yyrestart().

#define YY_BUFFER_EOF_PENDING   2

Definition at line 267 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_get_next_buffer().

#define YY_BUFFER_NEW   0

Definition at line 255 of file flex_scanner.cpp.

Referenced by while(), and yyFlexLexer::yy_flush_buffer().

#define YY_BUFFER_NORMAL   1

Definition at line 256 of file flex_scanner.cpp.

Referenced by while().

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 278 of file flex_scanner.cpp.

Referenced by if(), yyFlexLexer::switch_streams(), yyFlexLexer::yy_delete_buffer(), yyFlexLexer::yy_flush_buffer(), yyFlexLexer::yy_get_next_buffer(), yyFlexLexer::yy_init_buffer(), yyFlexLexer::yy_switch_to_buffer(), yyFlexLexer::yypop_buffer_state(), yyFlexLexer::yypush_buffer_state(), yyFlexLexer::yyrestart(), and yyFlexLexer::~yyFlexLexer().

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 285 of file flex_scanner.cpp.

Referenced by if(), while(), yyFlexLexer::yy_delete_buffer(), yyFlexLexer::yy_get_next_buffer(), yyFlexLexer::yy_load_buffer_state(), yyFlexLexer::yy_switch_to_buffer(), yyFlexLexer::yyinput(), yyFlexLexer::yypop_buffer_state(), yyFlexLexer::yypush_buffer_state(), yyFlexLexer::yyrestart(), and yyFlexLexer::yyunput().

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
  yyleng = (size_t) (yy_cp - yy_bp); \
  (yy_hold_char) = *yy_cp; \
  *yy_cp = '\0'; \
  (yy_c_buf_p) = yy_cp;

Definition at line 326 of file flex_scanner.cpp.

Referenced by while().

#define YY_END_OF_BUFFER   16

Definition at line 334 of file flex_scanner.cpp.

Referenced by while().

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 153 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_flush_buffer(), yyFlexLexer::yy_get_next_buffer(), and yyFlexLexer::yyinput().

#define YY_EXIT_FAILURE   2

Definition at line 1655 of file flex_scanner.cpp.

Referenced by yyFlexLexer::LexerError().

#define YY_EXTRA_TYPE   void *

Definition at line 528 of file flex_scanner.cpp.

#define YY_FATAL_ERROR

(

msg

)

LexerError( msg )

Definition at line 584 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_create_buffer(), yyFlexLexer::yy_get_next_buffer(), yyFlexLexer::yy_pop_state(), yyFlexLexer::yy_push_state(), yyFlexLexer::yyensure_buffer_stack(), and yyFlexLexer::yyunput().

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 10 of file flex_scanner.cpp.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 11 of file flex_scanner.cpp.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 12 of file flex_scanner.cpp.

#define YY_INPUT	(		buf,
			result,
			max_size
	)

Value:

\
  if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
    YY_FATAL_ERROR( "input in flex scanner failed" );

Definition at line 562 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_get_next_buffer().

#define YY_INT_ALIGNED   short int

Definition at line 5 of file flex_scanner.cpp.

#define YY_LESS_LINENO

(

n

)

Definition at line 183 of file flex_scanner.cpp.

#define YY_MORE_ADJ   0

Definition at line 480 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_next_buffer(), and yyFlexLexer::yy_get_previous_state().

#define yy_new_buffer   yy_create_buffer

Definition at line 291 of file flex_scanner.cpp.

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 151 of file flex_scanner.cpp.

Referenced by while(), and yyFlexLexer::yyinput().

#define YY_NO_UNISTD_H

Definition at line 500 of file flex_scanner.cpp.

#define YY_NULL   0

Definition at line 125 of file flex_scanner.cpp.

#define YY_NUM_RULES   15

Definition at line 333 of file flex_scanner.cpp.

#define YY_READ_BUF_SIZE   8192

Definition at line 549 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_get_next_buffer().

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 481 of file flex_scanner.cpp.

Referenced by while().

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 609 of file flex_scanner.cpp.

Referenced by while().

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 132 of file flex_scanner.cpp.

Referenced by while(), and yyFlexLexer::yy_get_previous_state().

#define yy_set_bol

(

at_bol

)

Value:

{ \
  if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (); \
    YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE ); \
  } \
  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  }

Definition at line 303 of file flex_scanner.cpp.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
  if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
    YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE ); \
  } \
  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  }

Definition at line 293 of file flex_scanner.cpp.

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 144 of file flex_scanner.cpp.

Referenced by while(), and yyFlexLexer::yy_push_state().

#define YY_START_STACK_INCR   25

Definition at line 579 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_push_state().

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 170 of file flex_scanner.cpp.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 148 of file flex_scanner.cpp.

Referenced by while().

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 207 of file flex_scanner.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 173 of file flex_scanner.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 202 of file flex_scanner.cpp.

#define YY_USER_ACTION   yylloc->columns(yyleng);

Definition at line 514 of file flex_scanner.cpp.

#define yyconst

Definition at line 121 of file flex_scanner.cpp.

#define yyFlexLexer   SlamFlexLexer

Definition at line 23 of file flex_scanner.cpp.

#define yyless

(

n

)

Value:

do \
    { \
    /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
    *yy_cp = (yy_hold_char); \
    YY_RESTORE_YY_MORE_OFFSET \
    (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    } \
  while ( 0 )

Definition at line 1667 of file flex_scanner.cpp.

#define yyless

(

n

)

Value:

do \
    { \
    /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
    yytext[yyleng] = (yy_hold_char); \
    (yy_c_buf_p) = yytext + yyless_macro_arg; \
    (yy_hold_char) = *(yy_c_buf_p); \
    *(yy_c_buf_p) = '\0'; \
    yyleng = yyless_macro_arg; \
    } \
  while ( 0 )

Definition at line 1667 of file flex_scanner.cpp.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 479 of file flex_scanner.cpp.

#define YYSTATE   YY_START

Definition at line 145 of file flex_scanner.cpp.

#define YYTABLES_NAME   "yytables"

Definition at line 1729 of file flex_scanner.cpp.

#define yyterminate

(

)

return token::END

Definition at line 496 of file flex_scanner.cpp.

Referenced by while().

#define yytext_ptr   yytext

Definition at line 319 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_next_buffer(), yyFlexLexer::yy_get_previous_state(), yyFlexLexer::yy_load_buffer_state(), yyFlexLexer::yyinput(), and yyFlexLexer::yyunput().

Typedef Documentation

typedef short int flex_int16_t

Definition at line 56 of file flex_scanner.cpp.

typedef int flex_int32_t

Definition at line 57 of file flex_scanner.cpp.

typedef signed char flex_int8_t

Definition at line 55 of file flex_scanner.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 59 of file flex_scanner.cpp.

typedef unsigned int flex_uint32_t

Definition at line 60 of file flex_scanner.cpp.

typedef unsigned char flex_uint8_t

Definition at line 58 of file flex_scanner.cpp.

typedef SlamParser::Parser::token token

Definition at line 491 of file flex_scanner.cpp.

typedef SlamParser::Parser::token_type token_type

Definition at line 492 of file flex_scanner.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 174 of file flex_scanner.cpp.

typedef unsigned char YY_CHAR

Definition at line 317 of file flex_scanner.cpp.

typedef size_t yy_size_t

Definition at line 203 of file flex_scanner.cpp.

Function Documentation

if

(

!

yy_init

)

Definition at line 633 of file flex_scanner.cpp.

References YY_BUF_SIZE, YY_CURRENT_BUFFER, and YY_CURRENT_BUFFER_LVALUE.

Referenced by yyFlexLexer::yyunput().

    {
    (yy_init) = 1;

#ifdef YY_USER_INIT
    YY_USER_INIT;
#endif

    if ( ! (yy_start) )
      (yy_start) = 1;  /* first start state */

    if ( ! yyin )
      yyin = & std::cin;

    if ( ! yyout )
      yyout = & std::cout;

    if ( ! YY_CURRENT_BUFFER ) {
      yyensure_buffer_stack ();
      YY_CURRENT_BUFFER_LVALUE =
        yy_create_buffer( yyin, YY_BUF_SIZE );
    }

    yy_load_buffer_state(  );
    }

int isatty

(

int

)

Referenced by yyFlexLexer::yy_delete_buffer().

void * Slamalloc

(

yy_size_t

size

)

Definition at line 1707 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_create_buffer(), yyFlexLexer::yy_push_state(), and yyFlexLexer::yyensure_buffer_stack().

{
  return (void *) malloc( size );
}

void Slamfree

(

void *

ptr

)

Definition at line 1724 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_delete_buffer(), and yyFlexLexer::~yyFlexLexer().

{
  free( (char *) ptr );  /* see Slamrealloc() for (char *) cast */
}

void * Slamrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 1712 of file flex_scanner.cpp.

Referenced by yyFlexLexer::yy_get_next_buffer(), yyFlexLexer::yy_push_state(), and yyFlexLexer::yyensure_buffer_stack().

{
  /* The cast to (char *) in the following accommodates both
   * implementations that use char* generic pointers, and those
   * that use void* generic pointers.  It works with the latter
   * because both ANSI C and C++ allow castless assignment from
   * any pointer type to void*, and deal with argument conversions
   * as though doing an assignment.
   */
  return (void *) realloc( (char *) ptr, size );
}

yylloc step

(

)

Referenced by g2o::RobotLaser::setOdomPose().

while

(

1

)

Definition at line 659 of file flex_scanner.cpp.

References SlamParser::Parser::token::ADD, SlamParser::Parser::token::DOUBLE, SlamParser::Parser::token::E_SE2, SlamParser::Parser::token::E_SE3, ECHO, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, SlamParser::Parser::token::EOL, SlamParser::Parser::token::FIX, INITIAL, SlamParser::Parser::token::INTEGER, SlamParser::Parser::token::QUERY_STATE, SlamParser::Parser::token::SOLVE_STATE, SlamParser::Parser::token::STRING, SlamParser::Parser::token::V_SE2, SlamParser::Parser::token::V_SE3, yy_accept, yy_base, YY_BREAK, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_chk, yy_cp, YY_CURRENT_BUFFER_LVALUE, yy_def, YY_DO_BEFORE_ACTION, yy_ec, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_meta, YY_MORE_ADJ, yy_buffer_state::yy_n_chars, YY_NEW_FILE, yy_nxt, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, YY_STATE_EOF, yyleng, yyterminate, and yytext_ptr.

    {
    yy_cp = (yy_c_buf_p);

    /* Support of yytext. */
    *yy_cp = (yy_hold_char);

    /* yy_bp points to the position in yy_ch_buf of the start of
     * the current run.
     */
    yy_bp = yy_cp;

    yy_current_state = (yy_start);
yy_match:
    do
      {
      YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
      if ( yy_accept[yy_current_state] )
        {
        (yy_last_accepting_state) = yy_current_state;
        (yy_last_accepting_cpos) = yy_cp;
        }
      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
        {
        yy_current_state = (int) yy_def[yy_current_state];
        if ( yy_current_state >= 77 )
          yy_c = yy_meta[(unsigned int) yy_c];
        }
      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
      ++yy_cp;
      }
    while ( yy_current_state != 76 );
    yy_cp = (yy_last_accepting_cpos);
    yy_current_state = (yy_last_accepting_state);

yy_find_action:
    yy_act = yy_accept[yy_current_state];

    YY_DO_BEFORE_ACTION;

do_action:  /* This label is used only to access EOF actions. */

    switch ( yy_act )
  { /* beginning of action switch */
      case 0: /* must back up */
      /* undo the effects of YY_DO_BEFORE_ACTION */
      *yy_cp = (yy_hold_char);
      yy_cp = (yy_last_accepting_cpos);
      yy_current_state = (yy_last_accepting_state);
      goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 59 "scanner.l"
{
  yylval->integerVal = atoi(yytext);
  return token::INTEGER;
}
  YY_BREAK
case 2:
YY_RULE_SETUP
#line 64 "scanner.l"
{
  yylval->doubleVal = atof(yytext);
  return token::DOUBLE;
}
  YY_BREAK
case 3:
YY_RULE_SETUP
#line 69 "scanner.l"
{
  /*yylval->stringVal = new std::string(yytext, yyleng);*/
  return token::ADD;
}
  YY_BREAK
case 4:
YY_RULE_SETUP
#line 74 "scanner.l"
{
  yylval->stringVal = new std::string(yytext, yyleng);
  return token::V_SE2;
}
  YY_BREAK
case 5:
YY_RULE_SETUP
#line 79 "scanner.l"
{
  yylval->stringVal = new std::string(yytext, yyleng);
  return token::V_SE3;
}
  YY_BREAK
case 6:
YY_RULE_SETUP
#line 84 "scanner.l"
{
  yylval->stringVal = new std::string(yytext, yyleng);
  return token::E_SE2;
}
  YY_BREAK
case 7:
YY_RULE_SETUP
#line 89 "scanner.l"
{
  yylval->stringVal = new std::string(yytext, yyleng);
  return token::E_SE3;
}
  YY_BREAK
case 8:
YY_RULE_SETUP
#line 94 "scanner.l"
{
  /*yylval->stringVal = new std::string(yytext, yyleng);*/
  return token::FIX;
}
  YY_BREAK
case 9:
YY_RULE_SETUP
#line 99 "scanner.l"
{
  /*yylval->stringVal = new std::string(yytext, yyleng);*/
  return token::SOLVE_STATE;
}
  YY_BREAK
case 10:
YY_RULE_SETUP
#line 104 "scanner.l"
{
  /*yylval->stringVal = new std::string(yytext, yyleng);*/
  return token::QUERY_STATE;
}
  YY_BREAK
case 11:
YY_RULE_SETUP
#line 109 "scanner.l"
{
    yylval->stringVal = new std::string(yytext, yyleng);
    return token::STRING;
}
  YY_BREAK
/* gobble up white-spaces */
case 12:
YY_RULE_SETUP
#line 115 "scanner.l"
{
    yylloc->step();
}
  YY_BREAK
/* gobble up end-of-lines */
case 13:
/* rule 13 can match eol */
YY_RULE_SETUP
#line 120 "scanner.l"
{
    yylloc->lines(yyleng); yylloc->step();
    return token::EOL;
}
  YY_BREAK
/* pass all other characters up to bison */
case 14:
YY_RULE_SETUP
#line 126 "scanner.l"
{
    return static_cast<token_type>(*yytext);
}
  YY_BREAK
/*** END EXAMPLE - Change the example lexer rules above ***/
case 15:
YY_RULE_SETUP
#line 132 "scanner.l"
ECHO;
  YY_BREAK
#line 831 "flex_scanner.cpp"
case YY_STATE_EOF(INITIAL):
  yyterminate();

  case YY_END_OF_BUFFER:
    {
    /* Amount of text matched not including the EOB char. */
    int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

    /* Undo the effects of YY_DO_BEFORE_ACTION. */
    *yy_cp = (yy_hold_char);
    YY_RESTORE_YY_MORE_OFFSET

    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
      {
      /* We're scanning a new file or input source.  It's
       * possible that this happened because the user
       * just pointed yyin at a new source and called
       * yylex().  If so, then we have to assure
       * consistency between YY_CURRENT_BUFFER and our
       * globals.  Here is the right place to do so, because
       * this is the first action (other than possibly a
       * back-up) that will match for the new input source.
       */
      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
      YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
      }

    /* Note that here we test for yy_c_buf_p "<=" to the position
     * of the first EOB in the buffer, since yy_c_buf_p will
     * already have been incremented past the NUL character
     * (since all states make transitions on EOB to the
     * end-of-buffer state).  Contrast this with the test
     * in input().
     */
    if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
      { /* This was really a NUL. */
      yy_state_type yy_next_state;

      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

      yy_current_state = yy_get_previous_state(  );

      /* Okay, we're now positioned to make the NUL
       * transition.  We couldn't have
       * yy_get_previous_state() go ahead and do it
       * for us because it doesn't know how to deal
       * with the possibility of jamming (and we don't
       * want to build jamming into it because then it
       * will run more slowly).
       */

      yy_next_state = yy_try_NUL_trans( yy_current_state );

      yy_bp = (yytext_ptr) + YY_MORE_ADJ;

      if ( yy_next_state )
        {
        /* Consume the NUL. */
        yy_cp = ++(yy_c_buf_p);
        yy_current_state = yy_next_state;
        goto yy_match;
        }

      else
        {
        yy_cp = (yy_last_accepting_cpos);
        yy_current_state = (yy_last_accepting_state);
        goto yy_find_action;
        }
      }

    else switch ( yy_get_next_buffer(  ) )
      {
      case EOB_ACT_END_OF_FILE:
        {
        (yy_did_buffer_switch_on_eof) = 0;

        if ( yywrap(  ) )
          {
          /* Note: because we've taken care in
           * yy_get_next_buffer() to have set up
           * yytext, we can now set up
           * yy_c_buf_p so that if some total
           * hoser (like flex itself) wants to
           * call the scanner after we return the
           * YY_NULL, it'll still work - another
           * YY_NULL will get returned.
           */
          (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

          yy_act = YY_STATE_EOF(YY_START);
          goto do_action;
          }

        else
          {
          if ( ! (yy_did_buffer_switch_on_eof) )
            YY_NEW_FILE;
          }
        break;
        }

      case EOB_ACT_CONTINUE_SCAN:
        (yy_c_buf_p) =
          (yytext_ptr) + yy_amount_of_matched_text;

        yy_current_state = yy_get_previous_state(  );

        yy_cp = (yy_c_buf_p);
        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
        goto yy_match;

      case EOB_ACT_LAST_MATCH:
        (yy_c_buf_p) =
        &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

        yy_current_state = yy_get_previous_state(  );

        yy_cp = (yy_c_buf_p);
        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
        goto yy_find_action;
      }
    break;
    }

  default:
    YY_FATAL_ERROR(
      "fatal flex scanner internal error--no action found" );
  } /* end of action switch */
    } /* end of scanning one token */

Variable Documentation

yyconst flex_int16_t yy_accept[77]

static

Initial value:

=
    {   0,
        0,    0,   16,   14,   12,   13,   14,   14,    1,   11,
       11,   11,   11,   11,   11,   11,   12,    0,    1,    2,
        2,    1,    0,   11,   11,   11,   11,   11,   11,   11,
        2,    0,    2,    3,   11,    8,   11,   11,   11,   11,
       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
       11,   11,   11,   11,   11,    6,   11,   11,   11,   11,
       11,   11,   11,   11,   11,   11,   11,    4,   11,    7,
       10,    9,   11,   11,    5,    0
    }

Definition at line 342 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

int yy_act

Definition at line 618 of file flex_scanner.cpp.

yyconst flex_int16_t yy_base[78]

static

Initial value:

=
    {   0,
        0,    0,  170,  173,  167,  173,   40,  160,   42,   40,
        0,   41,   38,   32,   39,   45,  163,  153,   51,   52,
       53,   73,   82,    0,   57,   63,   53,   67,   73,   71,
       87,  147,  146,    0,   80,    0,   73,   70,   78,  103,
       75,   90,   91,   80,   41,   39,   81,   81,   88,   93,
       38,  105,   93,   94,   92,    0,  103,  120,  121,  111,
      120,  117,  118,  121,  115,  132,  133,    0,  127,    0,
        0,    0,  134,  127,    0,  173,   60
    }

Definition at line 395 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

char * yy_bp

Definition at line 617 of file flex_scanner.cpp.

yyconst flex_int16_t yy_chk[220]

static

Initial value:

=
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    7,    7,    9,    9,
       10,   12,   13,    9,   14,   15,   16,   19,   19,   20,
       21,   77,   19,   20,   21,   51,   46,   25,   45,   10,
       12,   13,    9,   14,   15,   16,   26,   27,   28,   22,
       22,   19,   20,   21,   22,   23,   25,   23,   29,   23,
       30,   35,   37,   38,   31,   26,   27,   28,   31,   39,

       41,   42,   43,   22,   44,   47,   48,   29,   49,   30,
       35,   37,   38,   50,   53,   54,   55,   31,   39,   41,
       42,   43,   57,   44,   47,   48,   52,   49,   58,   59,
       40,   52,   50,   53,   54,   55,   60,   61,   62,   63,
       65,   57,   64,   66,   67,   52,   69,   64,   58,   59,
       52,   73,   74,   33,   32,   60,   61,   62,   63,   65,
       18,   64,   66,   67,   17,   69,   64,    8,    5,    3,
       73,   74,   76,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,

       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76
    }

Definition at line 447 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

char* yy_cp

Definition at line 617 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yyunput().

YY_DECL

Initial value:

{
  yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 615 of file flex_scanner.cpp.

yyconst flex_int16_t yy_def[78]

static

Initial value:

=
    {   0,
       76,    1,   76,   76,   76,   76,   76,   76,   76,   77,
       77,   77,   77,   77,   77,   77,   76,   76,   76,   76,
       76,   76,   76,   77,   77,   77,   77,   77,   77,   77,
       76,   76,   76,   77,   77,   77,   77,   77,   77,   77,
       77,   77,   77,   77,   77,   77,   77,   77,   77,   77,
       77,   77,   77,   77,   77,   77,   77,   77,   77,   77,
       77,   77,   77,   77,   77,   77,   77,   77,   77,   77,
       77,   77,   77,   77,   77,    0,   76
    }

Definition at line 407 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

yyconst flex_int32_t yy_ec[256]

static

Definition at line 354 of file flex_scanner.cpp.

Referenced by while(), and yyFlexLexer::yy_get_previous_state().

yyconst flex_int32_t yy_meta[47]

static

Initial value:

=
    {   0,
        1,    1,    1,    1,    2,    2,    2,    2,    2,    2,
        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
        2,    2,    2,    2,    2,    2
    }

Definition at line 386 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

yyconst flex_int16_t yy_nxt[220]

static

Initial value:

=
    {   0,
        4,    5,    6,    7,    4,    7,    8,    9,   10,   11,
       11,   12,   13,   11,   11,   11,   11,   11,   14,   11,
       15,   11,   11,   16,   11,   11,   11,    4,   10,   11,
       12,   13,   11,   11,   11,   11,   11,   14,   11,   15,
       11,   11,   16,   11,   11,   11,   18,   19,   21,   22,
       25,   26,   27,   23,   28,   29,   30,   21,   22,   20,
       31,   24,   23,   23,   23,   55,   50,   34,   49,   25,
       26,   27,   23,   28,   29,   30,   35,   36,   37,   21,
       22,   23,   23,   23,   23,   32,   34,   32,   38,   33,
       39,   40,   41,   42,   31,   35,   36,   37,   23,   43,

       45,   46,   47,   23,   48,   51,   52,   38,   53,   39,
       40,   41,   42,   54,   58,   59,   60,   23,   43,   45,
       46,   47,   61,   48,   51,   52,   56,   53,   62,   63,
       44,   57,   54,   58,   59,   60,   64,   65,   66,   67,
       70,   61,   68,   71,   72,   56,   73,   69,   62,   63,
       57,   74,   75,   33,   33,   64,   65,   66,   67,   70,
       20,   68,   71,   72,   17,   73,   69,   20,   17,   76,
       74,   75,    3,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,

       76,   76,   76,   76,   76,   76,   76,   76,   76,   76,
       76,   76,   76,   76,   76,   76,   76,   76,   76
    }

Definition at line 419 of file flex_scanner.cpp.

Referenced by while(), yyFlexLexer::yy_get_previous_state(), and yyFlexLexer::yy_try_NUL_trans().

int yyleng

Referenced by while().