mei_scanner.c File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <bft_mem.h>
#include <bft_error.h>
#include "mei_hash_table.h"
#include "mei_evaluate.h"
#include "mei_node.h"
#include "mei_parser.h"
#include "mei_parser_glob.h"
#include <unistd.h>

Data Structures
struct	yy_buffer_state
struct	yy_trans_info

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	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_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )
#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	YY_FLEX_LEX_COMPAT
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   24
#define	YY_END_OF_BUFFER   25
#define	REJECT
#define	yymore()   ((yy_more_offset) = yy_flex_strlen( yytext ))
#define	YY_NEED_STRLEN
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	YYLMAX   8192
#define	YY_INPUT(b, r, ms)   ( r = my_yyinput(b, ms) )
#define	INITIAL   0
#define	YY_EXTRA_TYPE   void *
#define	YY_READ_BUF_SIZE   8192
#define	ECHO   do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
#define	yyterminate()   return YY_NULL
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int yylex (void)
#define	YY_USER_ACTION
#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 int	yy_state_type

Functions
void	yyrestart (FILE *input_file)
void	yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE	yy_create_buffer (FILE *file, int size)
void	yy_delete_buffer (YY_BUFFER_STATE b)
void	yy_flush_buffer (YY_BUFFER_STATE b)
void	yypush_buffer_state (YY_BUFFER_STATE new_buffer)
void	yypop_buffer_state (void)
YY_BUFFER_STATE	yy_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	yy_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE	yy_scan_bytes (yyconst char *bytes, int len)
void *	yyalloc (yy_size_t)
void *	yyrealloc (void *, yy_size_t)
void	yyfree (void *)
int	my_yyinput (char *buffer, int max_size)
int	yylex_destroy (void)
int	yyget_debug (void)
void	yyset_debug (int debug_flag)
YY_EXTRA_TYPE	yyget_extra (void)
void	yyset_extra (YY_EXTRA_TYPE user_defined)
FILE *	yyget_in (void)
void	yyset_in (FILE *in_str)
FILE *	yyget_out (void)
void	yyset_out (FILE *out_str)
int	yyget_leng (void)
char *	yyget_text (void)
int	yyget_lineno (void)
void	yyset_lineno (int line_number)
int	yywrap (void)
int	yylex (void)
	if (!(yy_init))
	while (1)
int	isatty (int)

Variables
int	yyleng
FILE *	yyin = (FILE *) 0
FILE *	yyout = (FILE *) 0
int	yylineno = 1
char	yytext []
int	yy_flex_debug = 0
char *	yytext_ptr
char *	buff = NULL
size_t	len
	YY_DECL
register char *	yy_cp
register char *	yy_bp
register int	yy_act

Macro Definition Documentation

BEGIN

#define BEGIN   (yy_start) = 1 + 2 *

ECHO

#define ECHO   do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)

EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

FLEX_BETA

#define FLEX_BETA

FLEX_SCANNER

#define FLEX_SCANNER

FLEXINT_H

#define FLEXINT_H

INITIAL

#define INITIAL   0

INT16_MAX

#define INT16_MAX   (32767)

INT16_MIN

#define INT16_MIN   (-32767-1)

INT32_MAX

#define INT32_MAX   (2147483647)

INT32_MIN

#define INT32_MIN   (-2147483647-1)

INT8_MAX

#define INT8_MAX   (127)

INT8_MIN

#define INT8_MIN   (-128)

REJECT

#define REJECT

Value:

{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
++(yy_lp); \
goto find_rule; \
}

UINT16_MAX

#define UINT16_MAX   (65535U)

UINT32_MAX

#define UINT32_MAX   (4294967295U)

UINT8_MAX

#define UINT8_MAX   (255U)

unput

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

YY_AT_BOL

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

YY_BREAK

#define YY_BREAK   break;

YY_BUF_SIZE

#define YY_BUF_SIZE   16384

YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER

Value:

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

YY_CURRENT_BUFFER_LVALUE

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

YY_DECL

#define YY_DECL   int yylex (void)

YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

YY_DO_BEFORE_ACTION

#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'; \
        if ( yyleng + (yy_more_offset) >= YYLMAX ) \
                YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
        yy_flex_strncpy( &yytext[(yy_more_offset)], (yytext_ptr), yyleng + 1 ); \
        yyleng += (yy_more_offset); \
        (yy_prev_more_offset) = (yy_more_offset); \
        (yy_more_offset) = 0; \
        (yy_c_buf_p) = yy_cp;

YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   25

YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

YY_FATAL_ERROR

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

YY_FLEX_LEX_COMPAT

#define YY_FLEX_LEX_COMPAT

YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION   35

YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

YY_INPUT

#define YY_INPUT	(		b,
			r,
			ms
	)		( r = my_yyinput(b, ms) )

YY_INT_ALIGNED

#define YY_INT_ALIGNED   short int

YY_LESS_LINENO

#define YY_LESS_LINENO

(

n

)

Value:

do { \
                int yyl;\
                for ( yyl = n; yyl < yyleng; ++yyl )\
                    if ( yytext[yyl] == '\n' )\
                        --yylineno;\
            }while(0)

YY_MORE_ADJ

#define YY_MORE_ADJ   0

YY_NEED_STRLEN

#define YY_NEED_STRLEN

yy_new_buffer

#define yy_new_buffer   yy_create_buffer

YY_NEW_FILE

#define YY_NEW_FILE   yyrestart(yyin )

YY_NULL

#define YY_NULL   0

YY_NUM_RULES

#define YY_NUM_RULES   24

YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Value:

{ \
        (yy_more_offset) = (yy_prev_more_offset); \
        yyleng -= (yy_more_offset); \
        }

YY_RULE_SETUP

#define YY_RULE_SETUP   YY_USER_ACTION

YY_SC_TO_UI

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

yy_set_bol

#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; \
        }

yy_set_interactive

#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; \
        }

YY_START

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

YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

YY_STATE_BUF_SIZE

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

YY_STATE_EOF

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

YY_USER_ACTION

#define YY_USER_ACTION

yyconst

#define yyconst

yyless [1/2]

#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 )

yyless [2/2]

#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 )

YYLMAX

#define YYLMAX   8192

yymore

#define yymore

(

)

((yy_more_offset) = yy_flex_strlen( yytext ))

YYSTATE

#define YYSTATE   YY_START

YYTABLES_NAME

#define YYTABLES_NAME   "yytables"

yyterminate

#define yyterminate

(

)

return YY_NULL

Typedef Documentation

flex_int16_t

typedef short int flex_int16_t

flex_int32_t

typedef int flex_int32_t

flex_int8_t

typedef signed char flex_int8_t

flex_uint16_t

typedef unsigned short int flex_uint16_t

flex_uint32_t

typedef unsigned int flex_uint32_t

flex_uint8_t

typedef unsigned char flex_uint8_t

YY_BUFFER_STATE

typedef struct yy_buffer_state* YY_BUFFER_STATE

YY_CHAR

typedef unsigned char YY_CHAR

yy_size_t

typedef size_t yy_size_t

yy_state_type

typedef int yy_state_type

Function Documentation

if()

if

(

!

yy_init

)

isatty()

int isatty

(

int

)

my_yyinput()

int my_yyinput	(	char *	buffer,
		int	max_size
	)

while()

while

(

1

)

yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Here is the call graph for this function:

yy_delete_buffer()

void yy_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with yy_create_buffer()

Here is the call graph for this function:

yy_flush_buffer()

void yy_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer	(	char *	base,
		yy_size_t	size
	)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters

base	the character buffer
size	the size in bytes of the character buffer

Returns

the newly allocated buffer state object.

Here is the call graph for this function:

yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes	(	yyconst char *	yybytes,
		int	_yybytes_len
	)

Setup the input buffer state to scan the given bytes. The next call to yylex() will scan from a copy of bytes.

Parameters

yybytes	the byte buffer to scan
_yybytes_len	the number of bytes in the buffer pointed to by bytes.

Returns

the newly allocated buffer state object.

Here is the call graph for this function:

yy_scan_string()

YY_BUFFER_STATE yy_scan_string

(

yyconst char *

yystr

)

Setup the input buffer state to scan a string. The next call to yylex() will scan from a copy of str.

Parameters

yystr

a NUL-terminated string to scan

Returns

the newly allocated buffer state object.

Note

If you want to scan bytes that may contain NUL values, then use yy_scan_bytes() instead.

Here is the call graph for this function:

yy_switch_to_buffer()

void yy_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

yyalloc()

void * yyalloc

(

yy_size_t

size

)

yyfree()

void yyfree

(

void *

ptr

)

yyget_debug()

int yyget_debug

(

void

)

yyget_extra()

YY_EXTRA_TYPE yyget_extra

(

void

)

yyget_in()

FILE * yyget_in

(

void

)

Get the input stream.

yyget_leng()

int yyget_leng

(

void

)

Get the length of the current token.

yyget_lineno()

int yyget_lineno

(

void

)

Get the current line number.

yyget_out()

FILE * yyget_out

(

void

)

Get the output stream.

yyget_text()

char * yyget_text

(

void

)

Get the current token.

yylex()

int yylex

(

void

)

yylex_destroy()

int yylex_destroy

(

void

)

Here is the call graph for this function:

yypop_buffer_state()

void yypop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Here is the call graph for this function:

yypush_buffer_state()

void yypush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

yyrealloc()

void * yyrealloc	(	void *	ptr,
		yy_size_t	size
	)

yyrestart()

void yyrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

yyset_debug()

void yyset_debug

(

int

debug_flag

)

yyset_extra()

void yyset_extra

(

YY_EXTRA_TYPE

user_defined

)

yyset_in()

void yyset_in

(

FILE *

in_str

)

Set the input stream. This does not discard the current input buffer.

Parameters

in_str

A readable stream.

See also

yy_switch_to_buffer

yyset_lineno()

void yyset_lineno

(

int

line_number

)

Set the current line number.

Parameters

line_number

yyset_out()

void yyset_out

(

FILE *

out_str

)

yywrap()

int yywrap

(

void

)

Variable Documentation

buff

char* buff = NULL

len

size_t len

yy_act

register int yy_act

yy_bp

register char * yy_bp

yy_cp

register char* yy_cp

YY_DECL

YY_DECL

Initial value:

{
        register yy_state_type yy_current_state

The main scanner function which does all the work.

yy_flex_debug

int yy_flex_debug = 0

yyin

FILE * yyin = (FILE *) 0

yyleng

int yyleng

yylineno

int yylineno = 1

yyout

FILE * yyout = (FILE *) 0

yytext

char yytext

yytext_ptr

char* yytext_ptr