mei_parser.c File Reference

#include "cs_defs.h"
#include <string.h>
#include "bft_mem.h"
#include "bft_printf.h"
#include "mei_node.h"
#include "mei_parser_glob.h"
#include <limits.h>

Include dependency graph for mei_parser.c:

Macros
#define	YYBISON   1
#define	YYBISON_VERSION   "3.6.1"
#define	YYSKELETON_NAME   "yacc.c"
#define	YYPURE   0
#define	YYPUSH   0
#define	YYPULL   1
#define	YY_CAST(Type, Val)   ((Type) (Val))
#define	YY_REINTERPRET_CAST(Type, Val)   ((Type) (Val))
#define	YY_NULLPTR   ((void*)0)
#define	YY_YY_SRC_MEI_MEI_PARSER_H_INCLUDED
#define	YYDEBUG   0
#define	YYTOKENTYPE
#define	YYSTYPE_IS_TRIVIAL   1
#define	YYSTYPE_IS_DECLARED   1
#define	YYPTRDIFF_T   long
#define	YYPTRDIFF_MAXIMUM   LONG_MAX
#define	YYSIZE_T   unsigned
#define	YYSIZE_MAXIMUM
#define	YYSIZEOF(X)   YY_CAST (YYPTRDIFF_T, sizeof (X))
#define	YY_(Msgid)   Msgid
#define	YY_ATTRIBUTE_PURE
#define	YY_ATTRIBUTE_UNUSED
#define	YYUSE(E)   ((void) (E))
#define	YY_INITIAL_VALUE(Value)   Value
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YY_IGNORE_USELESS_CAST_BEGIN
#define	YY_IGNORE_USELESS_CAST_END
#define	YY_ASSERT(E)   ((void) (0 && (E)))
#define	YYSTACK_ALLOC   YYMALLOC
#define	YYSTACK_FREE   YYFREE
#define	YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define	YYMALLOC   malloc
#define	YYFREE   free
#define	YYSTACK_GAP_MAXIMUM   (YYSIZEOF (union yyalloc) - 1)
#define	YYSTACK_BYTES(N)
#define	YYCOPY_NEEDED   1
#define	YYSTACK_RELOCATE(Stack_alloc, Stack)
#define	YYCOPY(Dst, Src, Count)
#define	YYFINAL   34
#define	YYLAST   1149
#define	YYNTOKENS   38
#define	YYNNTS   5
#define	YYNRULES   38
#define	YYNSTATES   98
#define	YYMAXUTOK   277
#define	YYTRANSLATE(YYX)
#define	YY_ACCESSING_SYMBOL(State)   YY_CAST (yysymbol_kind_t, yystos[State])
#define	YYPACT_NINF   (-28)
#define	yypact_value_is_default(Yyn)   ((Yyn) == YYPACT_NINF)
#define	YYTABLE_NINF   (-37)
#define	yytable_value_is_error(Yyn)   0
#define	yyerrok   (yyerrstatus = 0)
#define	yyclearin   (yychar = YYEMPTY)
#define	YYACCEPT   goto yyacceptlab
#define	YYABORT   goto yyabortlab
#define	YYERROR   goto yyerrorlab
#define	YYRECOVERING()   (!!yyerrstatus)
#define	YYBACKUP(Token, Value)
#define	YYERRCODE   YYUNDEF
#define	YYDPRINTF(Args)   ((void) 0)
#define	YY_SYMBOL_PRINT(Title, Kind, Value, Location)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_REDUCE_PRINT(Rule)
#define	YYINITDEPTH   200
#define	YYMAXDEPTH   10000
#define	YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))

Typedefs
typedef enum yytokentype	yytoken_kind_t
typedef enum yysymbol_kind_t	yysymbol_kind_t
typedef signed char	yytype_int8
typedef short	yytype_int16
typedef unsigned char	yytype_uint8
typedef unsigned short	yytype_uint16
typedef yytype_int8	yy_state_t
typedef int	yy_state_fast_t

Enumerations
enum	yytokentype {   YYEMPTY = -2, YYEOF = 0, YYerror = 256, YYUNDEF = 257,   NUMBER = 258, VAR = 259, FUN1 = 260, FUN2 = 261,   FUN3 = 262, FUN4 = 263, IN1D = 264, WHILE = 265,   IF = 266, PRINT = 267, IFX = 268, ELSE = 269,   OR = 270, AND = 271, EQ = 272, NE = 273,   GE = 274, LE = 275, UMINUS = 276, UPLUS = 277,   YYEMPTY = -2, YYEOF = 0, YYerror = 256, YYUNDEF = 257,   NUMBER = 258, VAR = 259, FUN1 = 260, FUN2 = 261,   FUN3 = 262, FUN4 = 263, IN1D = 264, WHILE = 265,   IF = 266, PRINT = 267, IFX = 268, ELSE = 269,   OR = 270, AND = 271, EQ = 272, NE = 273,   GE = 274, LE = 275, UMINUS = 276, UPLUS = 277 }
enum	yysymbol_kind_t {   YYSYMBOL_YYEMPTY = -2, YYSYMBOL_YYEOF = 0, YYSYMBOL_YYerror = 1, YYSYMBOL_YYUNDEF = 2,   YYSYMBOL_NUMBER = 3, YYSYMBOL_VAR = 4, YYSYMBOL_FUN1 = 5, YYSYMBOL_FUN2 = 6,   YYSYMBOL_FUN3 = 7, YYSYMBOL_FUN4 = 8, YYSYMBOL_IN1D = 9, YYSYMBOL_WHILE = 10,   YYSYMBOL_IF = 11, YYSYMBOL_PRINT = 12, YYSYMBOL_IFX = 13, YYSYMBOL_ELSE = 14,   YYSYMBOL_15_ = 15, YYSYMBOL_OR = 16, YYSYMBOL_AND = 17, YYSYMBOL_EQ = 18,   YYSYMBOL_NE = 19, YYSYMBOL_GE = 20, YYSYMBOL_LE = 21, YYSYMBOL_22_ = 22,   YYSYMBOL_23_ = 23, YYSYMBOL_24_ = 24, YYSYMBOL_25_ = 25, YYSYMBOL_26_ = 26,   YYSYMBOL_27_ = 27, YYSYMBOL_28_ = 28, YYSYMBOL_UMINUS = 29, YYSYMBOL_UPLUS = 30,   YYSYMBOL_31_ = 31, YYSYMBOL_32_ = 32, YYSYMBOL_33_ = 33, YYSYMBOL_34_ = 34,   YYSYMBOL_35_ = 35, YYSYMBOL_36_ = 36, YYSYMBOL_37_ = 37, YYSYMBOL_YYACCEPT = 38,   YYSYMBOL_program = 39, YYSYMBOL_stmt_list = 40, YYSYMBOL_stmt = 41, YYSYMBOL_expr = 42 }
enum	{ YYENOMEM = -2 }

Functions
int	yyparse (void)
void *	malloc (YYSIZE_T)
void	free (void *)
static void	yydestruct (const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
void	yyerror (const char *s)

Variables
YYSTYPE	yylval
static const yytype_int8	yytranslate []
static const yytype_int16	yypact []
static const yytype_int8	yydefact []
static const yytype_int8	yypgoto []
static const yytype_int8	yydefgoto []
static const yytype_int8	yytable []
static const yytype_int8	yycheck []
static const yytype_int8	yystos []
static const yytype_int8	yyr1 []
static const yytype_int8	yyr2 []
int	yychar
int	yynerrs

Macro Definition Documentation

YY_

#define YY_

(

Msgid

)

Msgid

YY_ACCESSING_SYMBOL

#define YY_ACCESSING_SYMBOL

(

State

)

YY_CAST (yysymbol_kind_t, yystos[State])

Accessing symbol of state STATE.

YY_ASSERT

#define YY_ASSERT

(

E

)

((void) (0 && (E)))

YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

YY_CAST

#define YY_CAST	(		Type,
			Val
	)		((Type) (Val))

YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

YY_IGNORE_USELESS_CAST_BEGIN

#define YY_IGNORE_USELESS_CAST_BEGIN

YY_IGNORE_USELESS_CAST_END

#define YY_IGNORE_USELESS_CAST_END

YY_INITIAL_VALUE

#define YY_INITIAL_VALUE

(

Value

)

Value

YY_NULLPTR

#define YY_NULLPTR   ((void*)0)

YY_REDUCE_PRINT

#define YY_REDUCE_PRINT

(

Rule

)

YY_REINTERPRET_CAST

#define YY_REINTERPRET_CAST	(		Type,
			Val
	)		((Type) (Val))

YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top
	)

YY_SYMBOL_PRINT

#define YY_SYMBOL_PRINT	(		Title,
			Kind,
			Value,
			Location
	)

YY_YY_SRC_MEI_MEI_PARSER_H_INCLUDED

#define YY_YY_SRC_MEI_MEI_PARSER_H_INCLUDED

YYABORT

#define YYABORT   goto yyabortlab

YYACCEPT

#define YYACCEPT   goto yyacceptlab

YYBACKUP

#define YYBACKUP	(		Token,
			Value
	)

Value:

  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

YYBISON

#define YYBISON   1

YYBISON_VERSION

#define YYBISON_VERSION   "3.6.1"

yyclearin

#define yyclearin   (yychar = YYEMPTY)

YYCOPY

#define YYCOPY	(		Dst,
			Src,
			Count
	)

Value:

      do                                        \
        {                                       \
          YYPTRDIFF_T yyi;                      \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (0)

YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

YYDEBUG

#define YYDEBUG   0

YYDPRINTF

#define YYDPRINTF

(

Args

)

((void) 0)

YYERRCODE

#define YYERRCODE   YYUNDEF

yyerrok

#define yyerrok   (yyerrstatus = 0)

YYERROR

#define YYERROR   goto yyerrorlab

YYFINAL

#define YYFINAL   34

YYFREE

#define YYFREE   free

YYINITDEPTH

#define YYINITDEPTH   200

YYLAST

#define YYLAST   1149

YYMALLOC

#define YYMALLOC   malloc

YYMAXDEPTH

#define YYMAXDEPTH   10000

YYMAXUTOK

#define YYMAXUTOK   277

YYNNTS

#define YYNNTS   5

YYNRULES

#define YYNRULES   38

YYNSTATES

#define YYNSTATES   98

YYNTOKENS

#define YYNTOKENS   38

YYPACT_NINF

#define YYPACT_NINF   (-28)

yypact_value_is_default

#define yypact_value_is_default

(

Yyn

)

((Yyn) == YYPACT_NINF)

YYPOPSTACK

#define YYPOPSTACK

(

N

)

(yyvsp -= (N), yyssp -= (N))

YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM   LONG_MAX

YYPTRDIFF_T

#define YYPTRDIFF_T   long

YYPULL

#define YYPULL   1

YYPURE

#define YYPURE   0

YYPUSH

#define YYPUSH   0

YYRECOVERING

#define YYRECOVERING

(

)

(!!yyerrstatus)

YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM

Value:

  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

YYSIZE_T

#define YYSIZE_T   unsigned

YYSIZEOF

#define YYSIZEOF

(

X

)

YY_CAST (YYPTRDIFF_T, sizeof (X))

YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

YYSTACK_BYTES

#define YYSTACK_BYTES

(

N

)

Value:

     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

YYSTACK_GAP_MAXIMUM

#define YYSTACK_GAP_MAXIMUM   (YYSIZEOF (union yyalloc) - 1)

YYSTACK_RELOCATE

#define YYSTACK_RELOCATE	(		Stack_alloc,
			Stack
	)

Value:

    do                                                                  \
      {                                                                 \
        YYPTRDIFF_T yynewbytes;                                         \
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
      }                                                                 \
    while (0)

YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

YYTABLE_NINF

#define YYTABLE_NINF   (-37)

yytable_value_is_error

#define yytable_value_is_error

(

Yyn

)

0

YYTOKENTYPE

#define YYTOKENTYPE

YYTRANSLATE

#define YYTRANSLATE

(

YYX

)

Value:

  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
   : YYSYMBOL_YYUNDEF)

YYUSE

#define YYUSE

(

E

)

((void) (E))

Typedef Documentation

yy_state_fast_t

typedef int yy_state_fast_t

yy_state_t

typedef yytype_int8 yy_state_t

yysymbol_kind_t

typedef enum yysymbol_kind_t yysymbol_kind_t

yytoken_kind_t

typedef enum yytokentype yytoken_kind_t

yytype_int16

typedef short yytype_int16

yytype_int8

typedef signed char yytype_int8

yytype_uint16

typedef unsigned short yytype_uint16

yytype_uint8

typedef unsigned char yytype_uint8

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
YYENOMEM

yysymbol_kind_t

enum yysymbol_kind_t

Enumerator
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror
YYSYMBOL_YYUNDEF
YYSYMBOL_NUMBER
YYSYMBOL_VAR
YYSYMBOL_FUN1
YYSYMBOL_FUN2
YYSYMBOL_FUN3
YYSYMBOL_FUN4
YYSYMBOL_IN1D
YYSYMBOL_WHILE
YYSYMBOL_IF
YYSYMBOL_PRINT
YYSYMBOL_IFX
YYSYMBOL_ELSE
YYSYMBOL_15_
YYSYMBOL_OR
YYSYMBOL_AND
YYSYMBOL_EQ
YYSYMBOL_NE
YYSYMBOL_GE
YYSYMBOL_LE
YYSYMBOL_22_
YYSYMBOL_23_
YYSYMBOL_24_
YYSYMBOL_25_
YYSYMBOL_26_
YYSYMBOL_27_
YYSYMBOL_28_
YYSYMBOL_UMINUS
YYSYMBOL_UPLUS
YYSYMBOL_31_
YYSYMBOL_32_
YYSYMBOL_33_
YYSYMBOL_34_
YYSYMBOL_35_
YYSYMBOL_36_
YYSYMBOL_37_
YYSYMBOL_YYACCEPT
YYSYMBOL_program
YYSYMBOL_stmt_list
YYSYMBOL_stmt
YYSYMBOL_expr

yytokentype

enum yytokentype

Enumerator
YYEMPTY
YYEOF
YYerror
YYUNDEF
NUMBER
VAR
FUN1
FUN2
FUN3
FUN4
IN1D
WHILE
IF
PRINT
IFX
ELSE
OR
AND
EQ
NE
GE
LE
UMINUS
UPLUS
YYEMPTY
YYEOF
YYerror
YYUNDEF
NUMBER
VAR
FUN1
FUN2
FUN3
FUN4
IN1D
WHILE
IF
PRINT
IFX
ELSE
OR
AND
EQ
NE
GE
LE
UMINUS
UPLUS

Function Documentation

free()

void free

(

void *

)

malloc()

void* malloc

(

YYSIZE_T

)

yydestruct()

static void yydestruct ( const char *  yymsg, yysymbol_kind_t  yykind, YYSTYPE *  yyvaluep  )

static

yyerror()

void yyerror

(

const char *

s

)

yyparse()

int yyparse

(

void

)

Variable Documentation

yychar

int yychar

yycheck

const yytype_int8 yycheck[]

static

yydefact

const yytype_int8 yydefact[]

static

Initial value:

=
{
       2,    15,    16,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     6,     0,     0,     0,     3,     0,     0,
       0,     0,     0,     0,     0,     0,     0,    16,     0,     0,
       0,     0,     0,     0,     1,     0,    14,    38,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     7,     0,     0,     0,     0,     0,     0,     0,     8,
      37,    13,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     9,    17,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,    18,     0,     0,
       0,     0,     0,     0,    19,     0,     0,    20
}

yydefgoto

const yytype_int8 yydefgoto[]

static

Initial value:

=
{
      -1,    16,    17,    18,    19
}

yylval

YYSTYPE yylval

yynerrs

int yynerrs

yypact

const yytype_int16 yypact[]

static

Initial value:

=
{
    1043,   -28,   -11,   -27,   -26,   -25,   -23,   -15,   -14,   881,
     881,   881,   881,   -28,   881,  1043,    20,  1043,   195,  1063,
     881,   881,   881,   881,   881,   881,   881,   -28,  1090,    26,
     253,   280,   849,   828,   -28,   232,   -28,   -28,   881,   881,
     881,   881,   881,   881,   881,   881,   881,   881,   881,   881,
     881,   -28,  1117,   876,   658,   685,   712,   903,   930,   -28,
     -28,   -28,   307,   334,   361,   388,   415,   442,   469,   496,
     523,   550,   577,   604,   631,   -28,   -28,   881,   881,   881,
    1043,  1043,   957,   739,   766,    84,   121,   -28,   881,   881,
    1043,   984,   793,   158,   -28,   881,  1011,   -28
}

yypgoto

const yytype_int8 yypgoto[]

static

Initial value:

=
{
     -28,   -28,     6,    -8,    -9
}

yyr1

const yytype_int8 yyr1[]

static

Initial value:

=
{
       0,    38,    39,    39,    40,    40,    41,    41,    41,    41,
      41,    41,    41,    41,    41,    42,    42,    42,    42,    42,
      42,    42,    42,    42,    42,    42,    42,    42,    42,    42,
      42,    42,    42,    42,    42,    42,    42,    42,    42
}

yyr2

const yytype_int8 yyr2[]

static

Initial value:

=
{
       0,     2,     0,     1,     2,     1,     1,     2,     3,     4,
       5,     5,     7,     3,     2,     1,     1,     4,     6,     8,
      10,     2,     2,     2,     3,     3,     3,     3,     3,     3,
       3,     3,     3,     3,     3,     3,     3,     3,     2
}

yystos

const yytype_int8 yystos[]

static

Initial value:

=
{
       0,     3,     4,     5,     6,     7,     8,    10,    11,    12,
      24,    25,    28,    32,    33,    35,    39,    40,    41,    42,
      15,    33,    33,    33,    33,    33,    33,     4,    42,    42,
      42,    42,    42,    40,     0,    41,     1,     1,    16,    17,
      18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
      31,    32,    42,    42,    42,    42,    42,    42,    42,    32,
      34,    36,    42,    42,    42,    42,    42,    42,    42,    42,
      42,    42,    42,    42,    42,    32,    34,    37,    37,    37,
      34,    34,    42,    42,    42,    41,    41,    34,    37,    37,
      14,    42,    42,    41,    34,    37,    42,    34
}

yytable

const yytype_int8 yytable[]

static

yytranslate

const yytype_int8 yytranslate[]

static