space_constitution_old_get.cc

Go to the source code of this file.

Namespaces
namespace	rheolef
	This file is part of Rheolef.

Macros
#define	YYMALLOC   ::malloc
#define	YYFREE   ::free
#define	YYBISON   30704
#define	YYBISON_VERSION   "3.7.4"
#define	YYSKELETON_NAME   "yacc.c"
#define	YYPURE   0
#define	YYPUSH   0
#define	YYPULL   1
#define	yyparse
#define	yylex   space_constitution_old_lex
#define	yyerror   space_constitution_old_error
#define	yydebug   space_constitution_old_debug
#define	yynerrs   space_constitution_old_nerrs
#define	yylval   space_constitution_old_lval
#define	yychar   space_constitution_old_char
#define	YY_CAST(Type, Val)
#define	YY_REINTERPRET_CAST(Type, Val)
#define	YY_NULLPTR   ((void*)0)
#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)
#define	YY_(Msgid)
#define	YY_ATTRIBUTE_PURE
#define	YY_ATTRIBUTE_UNUSED
#define	YYUSE(E)
#define	YY_INITIAL_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)
#define	YYSTACK_ALLOC   YYMALLOC
#define	YYSTACK_FREE   YYFREE
#define	YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#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   14
#define	YYLAST   24
#define	YYNTOKENS   8
#define	YYNNTS   7
#define	YYNRULES   11
#define	YYNSTATES   24
#define	YYMAXUTOK   259
#define	YYTRANSLATE(YYX)
#define	YY_ACCESSING_SYMBOL(State)
#define	YYPACT_NINF   (-10)
#define	yypact_value_is_default(Yyn)
#define	YYTABLE_NINF   (-11)
#define	yytable_value_is_error(Yyn)
#define	yyerrok   (yyerrstatus = 0)
#define	yyclearin   (yychar = YYEMPTY)
#define	YYACCEPT   goto yyacceptlab
#define	YYABORT   goto yyabortlab
#define	YYERROR   goto yyerrorlab
#define	YYRECOVERING()
#define	YYBACKUP(Token, Value)
#define	YYERRCODE   YYUNDEF
#define	YYDPRINTF(Args)
#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)
#define	YY_INT_ALIGNED   short int
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   6
#define	YY_FLEX_SUBMINOR_VERSION   4
#define	FLEX_BETA
#define	yyFlexLexer   space_constitution_old_FlexLexer
#define	yyalloc   space_constitution_old_alloc
#define	yyrealloc   space_constitution_old_realloc
#define	yyfree   space_constitution_old_free
#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	SIZE_MAX   (~(size_t)0)
#define	yyconst   const
#define	yynoreturn
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)
#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	YY_TYPEDEF_YY_SIZE_T
#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	YY_LINENO_REWIND_TO(ptr)
#define	yyless(n)
#define	unput(c)
#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()
#define	YY_SKIP_YYWRAP
#define	yytext_ptr   yytext
#define	YY_INTERACTIVE
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   8
#define	YY_END_OF_BUFFER   9
#define	REJECT   reject_used_but_not_detected
#define	yymore()
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#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	yyterminate()
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int yyFlexLexer::yylex()
#define	YY_USER_ACTION
#define	YY_BREAK   /*LINTED*/break;
#define	YY_RULE_SETUP    YY_USER_ACTION
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Functions
int	space_constitution_old_lex ()
void	space_constitution_old_error (const char *msg)
int	space_constitution_old_wrap ()
int	space_constitution_old_parse (void)
int	yyparse (void)
void *	yyalloc (yy_size_t)
void *	yyrealloc (void *, yy_size_t)
void	yyfree (void *)
	if (!(yy_init))
template<class T, class M>
void	space_constitution_old_get (idiststream &ids, space_constitution< T, M > &constit)
template void	space_constitution_old_get (idiststream &, space_constitution< Float, sequential > &)
template void	space_constitution_old_get (idiststream &, space_constitution< Float, distributed > &)

Macro Definition Documentation

YYMALLOC

#define YYMALLOC   ::malloc

Definition at line 67 of file space_constitution_old_get.cc.

YYFREE

#define YYFREE   ::free

Definition at line 68 of file space_constitution_old_get.cc.

YYBISON

#define YYBISON   30704

YYBISON_VERSION

#define YYBISON_VERSION   "3.7.4"

YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

YYPURE

#define YYPURE   0

YYPUSH

#define YYPUSH   0

YYPULL

#define YYPULL   1

yyparse

#define yyparse

(

void

)

Value:

space_constitution_old_parse

yylex

#define yylex   space_constitution_old_lex

yyerror

#define yyerror   space_constitution_old_error

yydebug

#define yydebug   space_constitution_old_debug

yynerrs

#define yynerrs   space_constitution_old_nerrs

yylval

#define yylval   space_constitution_old_lval

yychar

#define yychar   space_constitution_old_char

YY_CAST

#define YY_CAST	(		Type,
			Val )

Value:

((Type) (Val))

YY_REINTERPRET_CAST

#define YY_REINTERPRET_CAST	(		Type,
			Val )

Value:

((Type) (Val))

YY_NULLPTR

#define YY_NULLPTR   ((void*)0)

YYDEBUG

#define YYDEBUG   0

YYTOKENTYPE

#define YYTOKENTYPE

YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

YYPTRDIFF_T

#define YYPTRDIFF_T   long

YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM   LONG_MAX

YYSIZE_T

#define YYSIZE_T   unsigned

YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM

Value:

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

YYSIZEOF

#define YYSIZEOF

(

X

)

Value:

YY_CAST (YYPTRDIFF_T, sizeof (X))

YY_

#define YY_

(

Msgid

)

Value:

Msgid

YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

YYUSE

#define YYUSE

(

E

)

Value:

((void) (E))

YY_INITIAL_VALUE

#define YY_INITIAL_VALUE

(

Value

)

Value:

Value

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_ASSERT

#define YY_ASSERT

(

E

)

Value:

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

YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

YYSTACK_GAP_MAXIMUM

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

YYSTACK_BYTES

#define YYSTACK_BYTES

(

N

)

Value:

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

YYCOPY_NEEDED

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

YYCOPY

#define YYCOPY	(		Dst,
			Src,
			Count )

Value:

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

YYFINAL

#define YYFINAL   14

YYLAST

#define YYLAST   24

YYNTOKENS

#define YYNTOKENS   8

YYNNTS

#define YYNNTS   7

YYNRULES

#define YYNRULES   11

YYNSTATES

#define YYNSTATES   24

YYMAXUTOK

#define YYMAXUTOK   259

YYTRANSLATE

#define YYTRANSLATE

(

YYX

)

Value:

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

YY_ACCESSING_SYMBOL

#define YY_ACCESSING_SYMBOL

(

State

)

Value:

YY_CAST (yysymbol_kind_t, yystos[State])

YYPACT_NINF

#define YYPACT_NINF   (-10)

yypact_value_is_default

#define yypact_value_is_default

(

Yyn

)

Value:

  ((Yyn) == YYPACT_NINF)

YYTABLE_NINF

#define YYTABLE_NINF   (-11)

yytable_value_is_error

#define yytable_value_is_error

(

Yyn

)

Value:

  0

yyerrok

#define yyerrok   (yyerrstatus = 0)

yyclearin

#define yyclearin   (yychar = YYEMPTY)

YYACCEPT

#define YYACCEPT   goto yyacceptlab

YYABORT

#define YYABORT   goto yyabortlab

YYERROR

#define YYERROR   goto yyerrorlab

YYRECOVERING

#define YYRECOVERING

(

)

Value:

(!!yyerrstatus)

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)

YYERRCODE

#define YYERRCODE   YYUNDEF

YYDPRINTF

#define YYDPRINTF

(

Args

)

Value:

((void) 0)

YY_SYMBOL_PRINT

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

YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top )

YY_REDUCE_PRINT

#define YY_REDUCE_PRINT

(

Rule

)

YYINITDEPTH

#define YYINITDEPTH   200

YYMAXDEPTH

#define YYMAXDEPTH   10000

YYPOPSTACK

#define YYPOPSTACK

(

N

)

Value:

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

YY_INT_ALIGNED

#define YY_INT_ALIGNED   short int

FLEX_SCANNER

#define FLEX_SCANNER

YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   6

YY_FLEX_SUBMINOR_VERSION

#define YY_FLEX_SUBMINOR_VERSION   4

FLEX_BETA

#define FLEX_BETA

yyFlexLexer

#define yyFlexLexer   space_constitution_old_FlexLexer

yyalloc

#define yyalloc   space_constitution_old_alloc

yyrealloc

#define yyrealloc   space_constitution_old_realloc

yyfree

#define yyfree   space_constitution_old_free

FLEXINT_H

#define FLEXINT_H

INT8_MIN

#define INT8_MIN   (-128)

INT16_MIN

#define INT16_MIN   (-32767-1)

INT32_MIN

#define INT32_MIN   (-2147483647-1)

INT8_MAX

#define INT8_MAX   (127)

INT16_MAX

#define INT16_MAX   (32767)

INT32_MAX

#define INT32_MAX   (2147483647)

UINT8_MAX

#define UINT8_MAX   (255U)

UINT16_MAX

#define UINT16_MAX   (65535U)

UINT32_MAX

#define UINT32_MAX   (4294967295U)

SIZE_MAX

#define SIZE_MAX   (~(size_t)0)

yyconst

#define yyconst   const

yynoreturn

#define yynoreturn

YY_NULL

#define YY_NULL   0

YY_SC_TO_UI

#define YY_SC_TO_UI

(

c

)

Value:

((YY_CHAR) (c))

BEGIN

#define BEGIN   (yy_start) = 1 + 2 *

YY_START

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

YYSTATE

#define YYSTATE   YY_START

YY_STATE_EOF

#define YY_STATE_EOF

(

state

)

Value:

(YY_END_OF_BUFFER + state + 1)

YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

YY_BUF_SIZE

#define YY_BUF_SIZE   16384

YY_STATE_BUF_SIZE

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

YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_BUFFER_STATE

YY_TYPEDEF_YY_SIZE_T

#define YY_TYPEDEF_YY_SIZE_T

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

YY_LESS_LINENO

#define YY_LESS_LINENO

(

n

)

YY_LINENO_REWIND_TO

#define YY_LINENO_REWIND_TO

(

ptr

)

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 )

unput

#define unput

(

c

)

Value:

yyunput( c, (yytext_ptr)  )

YY_STRUCT_YY_BUFFER_STATE

#define YY_STRUCT_YY_BUFFER_STATE

YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

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_new_buffer

#define yy_new_buffer   yy_create_buffer

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_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_AT_BOL

#define YY_AT_BOL

(

)

Value:

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

YY_SKIP_YYWRAP

#define YY_SKIP_YYWRAP

yytext_ptr

#define yytext_ptr   yytext

YY_INTERACTIVE

#define YY_INTERACTIVE

YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Value:

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

YY_NUM_RULES

#define YY_NUM_RULES   8

YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   9

REJECT

#define REJECT   reject_used_but_not_detected

yymore

#define yymore

(

)

Value:

yymore_used_but_not_detected

YY_MORE_ADJ

#define YY_MORE_ADJ   0

YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

INITIAL

#define INITIAL   0

YY_EXTRA_TYPE

#define YY_EXTRA_TYPE   void *

YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

ECHO

#define ECHO   LexerOutput( yytext, yyleng )

YY_INPUT

#define YY_INPUT	(		buf,
			result,
			max_size )

Value:

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

yyterminate

#define yyterminate

(

)

Value:

return YY_NULL

YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

YY_FATAL_ERROR

#define YY_FATAL_ERROR

(

msg

)

Value:

LexerError( msg )

YY_DECL_IS_OURS

#define YY_DECL_IS_OURS   1

YY_DECL

#define YY_DECL   int yyFlexLexer::yylex()

YY_USER_ACTION

#define YY_USER_ACTION

YY_BREAK

#define YY_BREAK   /*LINTED*/break;

YY_RULE_SETUP

#define YY_RULE_SETUP    YY_USER_ACTION

YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

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 )

YYTABLES_NAME

#define YYTABLES_NAME   "yytables"