Skip to content
Snippets Groups Projects
Select Git revision
  • 82ef2ab118fb009c015bd2404bcb003f25d6d6d1
  • master default protected
  • overlaps_tags_and_distributed_export
  • patches-4.14
  • steplayer
  • bl
  • pluginMeshQuality
  • fixBugsAmaury
  • hierarchical-basis
  • alphashapes
  • relaying
  • new_export_boris
  • oras_vs_osm
  • reassign_partitions
  • distributed_fwi
  • rename-classes
  • fix/fortran-api-example-t4
  • robust_partitions
  • reducing_files
  • fix_overlaps
  • 3115-issue-fix
  • gmsh_4_14_0
  • gmsh_4_13_1
  • gmsh_4_13_0
  • gmsh_4_12_2
  • gmsh_4_12_1
  • gmsh_4_12_0
  • gmsh_4_11_1
  • gmsh_4_11_0
  • gmsh_4_10_5
  • gmsh_4_10_4
  • gmsh_4_10_3
  • gmsh_4_10_2
  • gmsh_4_10_1
  • gmsh_4_10_0
  • gmsh_4_9_5
  • gmsh_4_9_4
  • gmsh_4_9_3
  • gmsh_4_9_2
  • gmsh_4_9_1
  • gmsh_4_9_0
41 results

t4.jl

Blame
  • Gmsh.yy.cpp 78.30 KiB
    #line 2 "Gmsh.yy.cpp"
    
    #line 4 "Gmsh.yy.cpp"
    
    #define  YY_INT_ALIGNED short int
    
    /* A lexical scanner generated by flex */
    
    #define FLEX_SCANNER
    #define YY_FLEX_MAJOR_VERSION 2
    #define YY_FLEX_MINOR_VERSION 5
    #define YY_FLEX_SUBMINOR_VERSION 33
    #if YY_FLEX_SUBMINOR_VERSION > 0
    #define FLEX_BETA
    #endif
    
    /* First, we deal with  platform-specific or compiler-specific issues. */
    
    /* begin standard C headers. */
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <stdlib.h>
    
    /* end standard C headers. */
    
    /* flex integer type definitions */
    
    #ifndef FLEXINT_H
    #define FLEXINT_H
    
    /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
    
    #if __STDC_VERSION__ >= 199901L
    
    /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
     * if you want the limit (max/min) macros for int types. 
     */
    #ifndef __STDC_LIMIT_MACROS
    #define __STDC_LIMIT_MACROS 1
    #endif
    
    #include <inttypes.h>
    typedef int8_t flex_int8_t;
    typedef uint8_t flex_uint8_t;
    typedef int16_t flex_int16_t;
    typedef uint16_t flex_uint16_t;
    typedef int32_t flex_int32_t;
    typedef uint32_t flex_uint32_t;
    #else
    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;
    #endif /* ! C99 */
    
    /* Limits of integral types. */
    #ifndef INT8_MIN
    #define INT8_MIN               (-128)
    #endif
    #ifndef INT16_MIN
    #define INT16_MIN              (-32767-1)
    #endif
    #ifndef INT32_MIN
    #define INT32_MIN              (-2147483647-1)
    #endif
    #ifndef INT8_MAX
    #define INT8_MAX               (127)
    #endif
    #ifndef INT16_MAX
    #define INT16_MAX              (32767)
    #endif
    #ifndef INT32_MAX
    #define INT32_MAX              (2147483647)
    #endif
    #ifndef UINT8_MAX
    #define UINT8_MAX              (255U)
    #endif
    #ifndef UINT16_MAX
    #define UINT16_MAX             (65535U)
    #endif
    #ifndef UINT32_MAX
    #define UINT32_MAX             (4294967295U)
    #endif
    
    #endif /* ! FLEXINT_H */
    
    #ifdef __cplusplus
    
    /* The "const" storage-class-modifier is valid. */
    #define YY_USE_CONST
    
    #else	/* ! __cplusplus */
    
    #if __STDC__
    
    #define YY_USE_CONST
    
    #endif	/* __STDC__ */
    #endif	/* ! __cplusplus */
    
    #ifdef YY_USE_CONST
    #define yyconst const
    #else
    #define yyconst
    #endif
    
    /* Returned upon end-of-file. */
    #define YY_NULL 0
    
    /* Promotes a possibly negative, possibly signed char to an unsigned
     * integer for use as an array index.  If the signed char is negative,
     * we want to instead treat it as an 8-bit unsigned char, hence the
     * double cast.
     */
    #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    
    /* Enter a start condition.  This macro really ought to take a parameter,
     * but we do it the disgusting crufty way forced on us by the ()-less
     * definition of BEGIN.
     */
    #define BEGIN (yy_start) = 1 + 2 *
    
    /* Translate the current start state into a value that can be later handed
     * to BEGIN to return to the state.  The YYSTATE alias is for lex
     * compatibility.
     */
    #define YY_START (((yy_start) - 1) / 2)
    #define YYSTATE YY_START
    
    /* Action number for EOF rule of a given start state. */
    #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    
    /* Special action meaning "start processing a new file". */
    #define YY_NEW_FILE gmsh_yyrestart(gmsh_yyin  )
    
    #define YY_END_OF_BUFFER_CHAR 0
    
    /* Size of default input buffer. */
    #ifndef YY_BUF_SIZE
    #define YY_BUF_SIZE 16384
    #endif
    
    /* The state buf must be large enough to hold one state per character in the main buffer.
     */
    #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
    
    #ifndef YY_TYPEDEF_YY_BUFFER_STATE
    #define YY_TYPEDEF_YY_BUFFER_STATE
    typedef struct yy_buffer_state *YY_BUFFER_STATE;
    #endif
    
    extern int gmsh_yyleng;
    
    extern FILE *gmsh_yyin, *gmsh_yyout;
    
    #define EOB_ACT_CONTINUE_SCAN 0
    #define EOB_ACT_END_OF_FILE 1
    #define EOB_ACT_LAST_MATCH 2
    
        #define YY_LESS_LINENO(n)
        
    /* Return all but the first "n" matched characters back to the input stream. */
    #define yyless(n) \
    	do \
    		{ \
    		/* Undo effects of setting up gmsh_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 gmsh_yytext again */ \
    		} \
    	while ( 0 )
    
    #define unput(c) yyunput( c, (yytext_ptr)  )
    
    /* The following is because we cannot portably get our hands on size_t
     * (without autoconf's help, which isn't available because we want
     * flex-generated scanners to compile on their own).
     */
    
    #ifndef YY_TYPEDEF_YY_SIZE_T
    #define YY_TYPEDEF_YY_SIZE_T
    typedef unsigned int yy_size_t;
    #endif
    
    #ifndef YY_STRUCT_YY_BUFFER_STATE
    #define YY_STRUCT_YY_BUFFER_STATE
    struct yy_buffer_state
    	{
    	FILE *yy_input_file;
    
    	char *yy_ch_buf;		/* input buffer */
    	char *yy_buf_pos;		/* current position in input buffer */
    
    	/* Size of input buffer in bytes, not including room for EOB
    	 * characters.
    	 */
    	yy_size_t yy_buf_size;
    
    	/* Number of characters read into yy_ch_buf, not including EOB
    	 * characters.
    	 */
    	int yy_n_chars;
    
    	/* Whether we "own" the buffer - i.e., we know we created it,
    	 * and can realloc() it to grow it, and should free() it to
    	 * delete it.
    	 */
    	int yy_is_our_buffer;
    
    	/* Whether this is an "interactive" input source; if so, and
    	 * if we're using stdio for input, then we want to use getc()
    	 * instead of fread(), to make sure we stop fetching input after
    	 * each newline.
    	 */
    	int yy_is_interactive;
    
    	/* Whether we're considered to be at the beginning of a line.
    	 * If so, '^' rules will be active on the next match, otherwise
    	 * not.
    	 */
    	int yy_at_bol;
    
        int yy_bs_lineno; /**< The line count. */
        int yy_bs_column; /**< The column count. */
        
    	/* Whether to try to fill the input buffer when we reach the
    	 * end of it.
    	 */
    	int yy_fill_buffer;
    
    	int yy_buffer_status;
    
    #define YY_BUFFER_NEW 0
    #define YY_BUFFER_NORMAL 1
    	/* When an EOF's been seen but there's still some text to process
    	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    	 * shouldn't try reading from the input source any more.  We might
    	 * still have a bunch of tokens to match, though, because of
    	 * possible backing-up.
    	 *
    	 * When we actually see the EOF, we change the status to "new"
    	 * (via gmsh_yyrestart()), so that the user can continue scanning by
    	 * just pointing gmsh_yyin at a new input file.
    	 */
    #define YY_BUFFER_EOF_PENDING 2
    
    	};
    #endif /* !YY_STRUCT_YY_BUFFER_STATE */
    
    /* Stack of input buffers. */
    static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
    static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
    static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
    
    /* We provide macros for accessing buffer states in case in the
     * future we want to put the buffer states in a more general
     * "scanner state".
     *
     * Returns the top of the stack, or NULL.
     */
    #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                              ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                              : NULL)
    
    /* Same as previous macro, but useful when we know that the buffer stack is not
     * NULL or when we need an lvalue. For internal use only.
     */
    #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
    
    /* yy_hold_char holds the character lost when gmsh_yytext is formed. */
    static char yy_hold_char;
    static int yy_n_chars;		/* number of characters read into yy_ch_buf */
    int gmsh_yyleng;
    
    /* Points to current character in buffer. */
    static char *yy_c_buf_p = (char *) 0;
    static int yy_init = 0;		/* whether we need to initialize */
    static int yy_start = 0;	/* start state number */
    
    /* Flag which is used to allow gmsh_yywrap()'s to do buffer switches
     * instead of setting up a fresh gmsh_yyin.  A bit of a hack ...
     */
    static int yy_did_buffer_switch_on_eof;
    
    void gmsh_yyrestart (FILE *input_file  );
    void gmsh_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
    YY_BUFFER_STATE gmsh_yy_create_buffer (FILE *file,int size  );
    void gmsh_yy_delete_buffer (YY_BUFFER_STATE b  );
    void gmsh_yy_flush_buffer (YY_BUFFER_STATE b  );
    void gmsh_yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
    void gmsh_yypop_buffer_state (void );
    
    static void gmsh_yyensure_buffer_stack (void );
    static void gmsh_yy_load_buffer_state (void );
    static void gmsh_yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
    
    #define YY_FLUSH_BUFFER gmsh_yy_flush_buffer(YY_CURRENT_BUFFER )
    
    YY_BUFFER_STATE gmsh_yy_scan_buffer (char *base,yy_size_t size  );
    YY_BUFFER_STATE gmsh_yy_scan_string (yyconst char *yy_str  );
    YY_BUFFER_STATE gmsh_yy_scan_bytes (yyconst char *bytes,int len  );
    
    void *gmsh_yyalloc (yy_size_t  );
    void *gmsh_yyrealloc (void *,yy_size_t  );
    void gmsh_yyfree (void *  );
    
    #define yy_new_buffer gmsh_yy_create_buffer
    
    #define yy_set_interactive(is_interactive) \
    	{ \
    	if ( ! YY_CURRENT_BUFFER ){ \
            gmsh_yyensure_buffer_stack (); \
    		YY_CURRENT_BUFFER_LVALUE =    \
                gmsh_yy_create_buffer(gmsh_yyin,YY_BUF_SIZE ); \
    	} \
    	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    	}
    
    #define yy_set_bol(at_bol) \
    	{ \
    	if ( ! YY_CURRENT_BUFFER ){\
            gmsh_yyensure_buffer_stack (); \
    		YY_CURRENT_BUFFER_LVALUE =    \
                gmsh_yy_create_buffer(gmsh_yyin,YY_BUF_SIZE ); \
    	} \
    	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    	}
    
    #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
    
    /* Begin user sect3 */
    
    typedef unsigned char YY_CHAR;
    
    FILE *gmsh_yyin = (FILE *) 0, *gmsh_yyout = (FILE *) 0;
    
    typedef int yy_state_type;
    
    extern int gmsh_yylineno;
    
    int gmsh_yylineno = 1;
    
    extern char *gmsh_yytext;
    #define yytext_ptr gmsh_yytext
    
    static yy_state_type yy_get_previous_state (void );
    static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
    static int yy_get_next_buffer (void );
    static void yy_fatal_error (yyconst char msg[]  );
    
    /* Done after the current pattern has been matched and before the
     * corresponding action - sets up gmsh_yytext.
     */
    #define YY_DO_BEFORE_ACTION \
    	(yytext_ptr) = yy_bp; \
    	gmsh_yyleng = (size_t) (yy_cp - yy_bp); \
    	(yy_hold_char) = *yy_cp; \
    	*yy_cp = '\0'; \
    	(yy_c_buf_p) = yy_cp;
    
    #define YY_NUM_RULES 147
    #define YY_END_OF_BUFFER 148
    /* This struct is not used in this scanner,
       but its presence is necessary. */
    struct yy_trans_info
    	{
    	flex_int32_t yy_verify;
    	flex_int32_t yy_nxt;
    	};
    static yyconst flex_int16_t yy_accept[634] =
        {   0,
            0,    0,  148,  146,    1,    1,  146,    5,  146,    6,
          146,  146,  146,  146,  146,  141,   21,    2,  146,   16,
          146,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  146,   28,   24,   19,   25,   17,   26,
           18,    0,  143,    3,    4,   20,  142,  141,    0,   29,
           27,   30,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,   86,   85,  145,  145,
    
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          104,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  131,  132,  145,  145,
          145,  145,  145,  145,  145,   23,   22,    0,  142,    0,
            0,  144,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  145,  145,  145,   49,
          145,  145,  145,  145,  145,  145,  145,  145,  145,   63,
          145,  145,  145,  145,  145,   76,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  145,  145,  145,   93,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
    
          145,  145,  145,  145,  145,  145,  145,  145,  145,  118,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          137,  145,  145,  145,  145,  145,    0,  143,    0,    0,
          142,   31,  145,  145,  145,  145,   35,   37,  145,  145,
          145,   57,  145,   44,  145,  145,  145,  145,  145,  145,
          145,   48,  145,  145,  145,  145,   62,  145,  145,  145,
          145,   71,  145,   72,  145,  145,   75,  145,  145,  145,
           82,   83,  145,  145,  145,  145,  145,  145,  145,   91,
          145,   92,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  114,  145,  145,  145,  145,  128,
    
          119,  145,  145,  145,  145,  117,  145,  145,  145,  145,
          145,  145,  133,  136,  145,  145,  145,  145,   10,   15,
            9,    8,  145,   12,   14,    0,  142,   33,  145,  145,
          145,   39,  145,  145,  145,  145,  145,  145,  145,   52,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
           69,  145,  145,   73,   74,  145,  145,  145,   84,  145,
          145,   89,  145,  145,  145,   94,  145,  145,  145,  100,
          145,  101,  145,  145,  105,  145,  106,  145,  145,  145,
          145,  145,  113,  145,  145,  145,  122,  145,  145,  145,
          145,  145,  145,  145,  138,  145,  139,  145,   11,  145,
    
           13,  145,   32,   36,   38,  145,   41,  145,  145,  145,
           45,  145,  145,  145,  145,  145,  145,  145,  145,   59,
           61,  145,  145,   68,  145,  145,  145,  145,  145,  145,
          145,  145,   95,   90,  145,  145,  145,   97,  145,  145,
          145,  110,  145,  109,  145,  115,  112,  145,  120,  121,
          145,  125,  145,  145,  145,  145,  145,  145,  145,  140,
            7,  145,   40,   42,  145,  145,  145,  145,  145,   47,
           51,  145,  145,  145,  145,   65,  145,  145,  145,   66,
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
          145,  145,  145,  145,  145,  145,  124,  145,  145,  123,
    
          145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
           54,  145,  145,  145,   64,   67,  145,   77,  145,  145,
          145,   78,  145,  145,   96,   98,   99,  102,  145,  103,
          145,  145,  116,  145,  145,  129,  145,  145,  145,  145,
          145,  145,  145,   46,  145,  145,  145,  145,   70,  145,
          145,  145,  145,   87,  145,  145,  111,  126,  145,  130,
          145,  135,  145,  145,   56,  145,   53,  145,  145,  145,
          145,  145,  145,  145,  107,  145,  145,  145,  145,   43,
          145,   55,  145,   60,  145,  145,  145,  145,  108,  127,
          134,  145,  145,  145,  145,  145,  145,  145,  145,  145,
    
          145,  145,  145,  145,  145,  145,   50,   58,  145,  145,
          145,  145,  145,  145,  145,  145,  145,   34,  145,  145,
          145,  145,  145,  145,  145,  145,   79,   80,   81,  145,
          145,   88,    0
        } ;
    
    static yyconst flex_int32_t yy_ec[256] =
        {   0,
            1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
            1,    2,    2,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    2,    4,    5,    1,    1,    1,    6,    7,    1,
            1,    8,    9,    1,   10,   11,   12,   13,   14,   15,
           16,   17,   17,   17,   17,   17,   17,   18,   19,   20,
           21,   22,    1,    1,   23,   24,   25,   26,   27,   28,
           29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
           39,   40,   41,   42,   43,   44,   45,   39,   39,   39,
            1,    1,    1,    1,   46,    1,   47,   48,   49,   50,
    
           51,   52,   53,   54,   55,   39,   56,   57,   58,   59,
           60,   61,   62,   63,   64,   65,   66,   67,   68,   69,
           70,   71,    1,   72,    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,
            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,    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
        } ;
    
    static yyconst flex_int32_t yy_meta[73] =
        {   0,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    2,    2,    2,    2,    2,    1,    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,    2,    2,    2,    2,    2,    2,
            2,    1
        } ;
    
    static yyconst flex_int16_t yy_base[635] =
        {   0,
            0,    0,  755,  756,  756,  756,  733,  756,  747,  756,
          731,   64,   65,   63,   75,   77,  756,  756,  730,  729,
          728,   46,   48,   66,   51,   65,   78,   46,   45,   71,
            0,  689,   90,   80,  681,   76,   99,  100,  103,  155,
          682,  685,  693,  671,  756,  756,  756,  756,  756,  756,
          756,  731,  161,  756,  756,  756,  166,  181,  190,  756,
          756,  756,    0,  681,  685,  690,  683,  690,  675,  664,
          668,   62,  678,  685,  668,  156,  679,   59,  672,  681,
          670,  676,  676,   87,  676,  672,  662,  661,  657,  660,
          677,  652,  666,  658,  653,  671,    0,  647,  651,  640,
    
           96,  650,  131,  677,  657,  643,  680,  654,  640,  632,
            0,  143,   27,  646,  641,  136,  634,  641,  637,  637,
          635,  165,  631,  630,  629,  165,    0,    0,  656,  631,
          639,  641,  632,  629,  617,  756,  756,  220,  225,  234,
          240,  245,  620,  636,  238,  623,  622,  623,  624,  619,
          620,  618,  618,  611,  624,  621,  611,  216,  607,  615,
          621,  616,  615,  618,  596,  608,  237,  605,  596,    0,
          597,  595,  601,  597,  606,    0,  606,  624,  609,  601,
          600,  590,  622,  597,  582,  595,  592,  593,  592,  628,
          580,  594,  573,  590,  596,  585,  588,  570,  574,  579,
    
          572,  583,  570,  578,  567,  560,  578,  573,  555,  568,
          561,  569,  564,  563,  552,  244,  564,  557,  565,  586,
          558,  564,  551,  550,  542,  226,  257,  281,  290,  295,
          300,    0,  543,  546,  550,  557,    0,  588,  547,  550,
          550,    0,  533,    0,  551,  540,  533,  532,  539,  228,
          543,    0,  527,  532,  525,  524,    0,  527,  527,  534,
          530,    0,  518,    0,  533,  519,    0,  516,  534,  532,
            0,    0,  513,  537,  513,  511,  511,  508,  515,    0,
          558,    0,  185,  513,  505,  514,  504,  508,  510,  513,
          508,  497,  498,  495,    0,  501,  495,  492,  506,    0,
    
            0,  490,  491,   84,  494,    0,  505,  488,  499,  502,
          497,  512,    0,    0,  476,  481,  491,  485,    0,    0,
          485,    0,  490,  483,    0,  305,  310,  494,  474,  478,
          477,    0,  476,  471,  478,  475,  482,  479,  478,  486,
          468,  475,  459,  469,  472,  471,  470,  469,  181,  456,
            0,  468,  467,    0,    0,  461,  293,  458,    0,  476,
          449,    0,  448,  457,  446,    0,  462,  453,  447,    0,
          459,    0,  454,  455,    0,  444,    0,  461,  449,  452,
          440,  447,    0,  443,  445,  444,    0,  429,  428,  441,
          434,  441,  424,  428,    0,  115,    0,  436,    0,  433,
    
            0,  430,    0,    0,  469,  432,    0,  423,  424,  415,
            0,  420,  431,  426,  407,  416,  415,  431,  409,    0,
            0,  176,  416,    0,  415,  418,  408,  306,  444,  400,
          428,  413,    0,    0,  412,  403,  390,    0,  399,  394,
          411,    0,  396,    0,  401,    0,    0,  404,    0,    0,
          402,    0,  401,  405,  400,  387,  399,  393,  400,    0,
            0,  381,    0,    0,  392,  404,  392,  393,  393,    0,
            0,  390,  392,  378,  390,    0,  372,  386,  387,    0,
          374,  400,  395,  388,  378,  394,  378,  361,  369,  373,
          372,  359,  364,  366,  360,  355,    0,  362,  351,    0,
    
          345,  363,  354,  347,  357,  386,  349,  345,  356,  349,
            0,  340,  343,  338,    0,    0,  343,    0,  364,  363,
          374,    0,  375,  332,    0,    0,    0,    0,  341,    0,
          344,  343,    0,  324,  337,    0,  334,  335,  338,  351,
          327,  328,  330,    0,  333,  332,  322,  330,    0,  340,
          339,  348,  335,    0,  327,  312,    0,    0,  307,    0,
          308,    0,  311,  302,    0,  306,    0,  305,  311,  317,
          320,  319,  318,  332,    0,  311,  310,  309,  294,    0,
          293,    0,  297,    0,  312,  311,  310,  316,    0,    0,
            0,  297,  296,  297,  322,  321,  320,  310,  285,  295,
    
          273,  302,  301,  300,  293,  279,    0,    0,  295,  294,
          293,  292,  268,  299,  271,  270,  267,    0,  254,  249,
          244,  237,  230,  185,  175,  162,    0,    0,    0,  152,
          105,    0,  756,   96
        } ;
    
    static yyconst flex_int16_t yy_def[635] =
        {   0,
          633,    1,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  633,  633,  633,  633,  633,
          633,  633,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  633,  633,  633,  633,
          633,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  633,  633,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
    
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,  634,  634,  634,  634,  634,  634,  634,  634,
          634,  634,    0,  633
        } ;
    
    static yyconst flex_int16_t yy_nxt[829] =
        {   0,
            4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
           14,   15,   16,   16,   16,   16,   16,   17,   18,   19,
           20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
           30,   31,   32,   33,   34,   35,   36,   37,   31,   38,
           39,   40,   41,   42,   31,   31,   31,   31,   31,   31,
           31,   31,   31,   31,   31,   31,   31,   31,   43,   31,
           31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
           31,   44,   48,   52,   50,   53,   53,   53,   53,   53,
           91,  201,   54,  202,   49,   51,   55,   57,   69,   58,
           58,   58,   58,   58,   64,   56,   92,   63,   70,   93,
    
          107,   78,   65,   59,   94,   79,   96,   71,   66,   67,
           68,  162,   72,   80,   95,  163,   73,  104,  151,   74,
           75,   81,   97,   82,   85,   76,  152,   59,   77,   98,
           83,  632,   86,   84,   87,   88,  100,   89,  108,  105,
          101,  169,  386,   90,  102,  109,  115,  170,  387,  103,
          116,  171,  110,  111,  187,  112,  119,  120,  113,  117,
          121,  114,  188,  122,  123,  118,  458,  124,  125,  127,
          128,  459,  126,   53,   53,   53,   53,   53,  139,  139,
          139,  139,  139,  190,  205,  129,  631,  138,  630,  199,
          191,   57,  140,   58,   58,   58,   58,   58,  141,  141,
    
          206,  130,  142,  142,  142,  142,  142,   59,  200,  156,
          629,  138,  157,  158,  131,  159,  140,  132,  212,  160,
          628,  213,  218,  219,  367,  368,  476,  214,  227,  227,
          477,   59,  228,  228,  228,  228,  228,  139,  139,  139,
          139,  139,  230,  230,  422,  423,  231,  231,  231,  231,
          231,  229,  142,  142,  142,  142,  142,  142,  142,  142,
          142,  142,  234,  249,  259,  627,  626,  260,  307,  228,
          228,  228,  228,  228,  319,  229,  250,  320,  235,  236,
          625,  308,  321,  309,  342,  624,  322,  343,  323,  324,
          623,  622,  325,  228,  228,  228,  228,  228,  326,  326,
    
          621,  620,  327,  327,  327,  327,  327,  231,  231,  231,
          231,  231,  231,  231,  231,  231,  231,  327,  327,  327,
          327,  327,  327,  327,  327,  327,  327,  428,  482,  619,
          429,  618,  617,  616,  615,  614,  483,  613,  612,  611,
          610,  609,  608,  607,  606,  605,  604,  603,  602,  601,
          600,  599,  598,  597,  596,  595,  594,  593,  592,  591,
          590,  589,  588,  587,  586,  585,  584,  583,  582,  581,
          580,  579,  578,  577,  576,  575,  574,  573,  572,  571,
          570,  569,  568,  567,  566,  565,  564,  563,  562,  561,
          560,  559,  558,  557,  556,  555,  554,  553,  552,  551,
    
          550,  549,  548,  547,  546,  545,  544,  543,  542,  541,
          540,  539,  538,  537,  536,  535,  534,  533,  532,  531,
          530,  529,  528,  527,  526,  525,  524,  523,  522,  521,
          520,  519,  518,  517,  516,  515,  514,  513,  512,  511,
          510,  509,  508,  507,  506,  505,  504,  503,  502,  501,
          500,  499,  498,  497,  496,  495,  494,  493,  492,  491,
          490,  489,  488,  487,  486,  485,  484,  481,  480,  479,
          478,  475,  474,  473,  472,  471,  470,  469,  468,  467,
          466,  465,  464,  463,  462,  461,  460,  457,  456,  455,
          454,  453,  452,  451,  450,  449,  448,  447,  446,  445,
    
          444,  443,  442,  441,  440,  439,  438,  437,  436,  435,
          434,  433,  432,  431,  430,  427,  426,  425,  424,  421,
          420,  419,  418,  417,  416,  415,  414,  413,  412,  411,
          410,  409,  408,  407,  406,  405,  404,  403,  402,  401,
          400,  399,  398,  397,  396,  395,  394,  393,  392,  391,
          390,  389,  388,  385,  384,  383,  382,  381,  380,  379,
          378,  377,  376,  375,  374,  373,  372,  371,  370,  369,
          366,  365,  364,  363,  362,  361,  360,  359,  358,  357,
          356,  355,  354,  353,  352,  351,  350,  349,  348,  347,
          346,  345,  344,  341,  340,  339,  338,  337,  336,  335,
    
          334,  333,  332,  331,  330,  329,  328,  318,  317,  316,
          315,  314,  313,  312,  311,  310,  306,  305,  304,  303,
          302,  301,  300,  299,  298,  297,  296,  295,  294,  293,
          292,  291,  290,  289,  288,  287,  286,  285,  284,  283,
          282,  281,  280,  279,  278,  277,  276,  275,  274,  273,
          272,  271,  270,  269,  268,  267,  266,  265,  264,  263,
          262,  261,  258,  257,  256,  255,  254,  253,  252,  251,
          248,  247,  246,  245,  244,  243,  242,  241,  240,  239,
          238,  237,  233,  232,  226,  225,  224,  223,  222,  221,
          220,  217,  216,  215,  211,  210,  209,  208,  207,  204,
    
          203,  198,  197,  196,  195,  194,  193,  192,  189,  186,
          185,  184,  183,  182,  181,  180,  179,  178,  177,  176,
          175,  174,  173,  172,  168,  167,  166,  165,  164,  161,
          155,  154,  153,  150,  149,  148,  147,  146,  145,  144,
          143,  137,  136,  135,  134,  133,  106,   99,   62,   61,
           60,   47,   46,   45,  633,    3,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
    
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633
        } ;
    
    static yyconst flex_int16_t yy_chk[829] =
        {   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,    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,   12,   14,   13,   14,   14,   14,   14,   14,
           28,  113,   15,  113,   12,   13,   15,   16,   23,   16,
           16,   16,   16,   16,   22,   15,   28,  634,   23,   29,
    
           36,   25,   22,   16,   29,   25,   30,   23,   22,   22,
           22,   78,   24,   25,   29,   78,   24,   34,   72,   24,
           24,   26,   30,   26,   27,   24,   72,   16,   24,   30,
           26,  631,   27,   26,   27,   27,   33,   27,   36,   34,
           33,   84,  304,   27,   33,   37,   38,   84,  304,   33,
           38,   84,   37,   37,  101,   37,   39,   39,   37,   38,
           39,   37,  101,   39,   39,   38,  396,   39,   39,   40,
           40,  396,   39,   53,   53,   53,   53,   53,   57,   57,
           57,   57,   57,  103,  116,   40,  630,   53,  626,  112,
          103,   58,   57,   58,   58,   58,   58,   58,   59,   59,
    
          116,   40,   59,   59,   59,   59,   59,   58,  112,   76,
          625,   53,   76,   76,   40,   76,   57,   40,  122,   76,
          624,  122,  126,  126,  283,  283,  422,  122,  138,  138,
          422,   58,  138,  138,  138,  138,  138,  139,  139,  139,
          139,  139,  140,  140,  349,  349,  140,  140,  140,  140,
          140,  139,  141,  141,  141,  141,  141,  142,  142,  142,
          142,  142,  145,  158,  167,  623,  622,  167,  216,  227,
          227,  227,  227,  227,  226,  139,  158,  226,  145,  145,
          621,  216,  226,  216,  250,  620,  226,  250,  226,  226,
          619,  617,  226,  228,  228,  228,  228,  228,  229,  229,
    
          616,  615,  229,  229,  229,  229,  229,  230,  230,  230,
          230,  230,  231,  231,  231,  231,  231,  326,  326,  326,
          326,  326,  327,  327,  327,  327,  327,  357,  428,  614,
          357,  613,  612,  611,  610,  609,  428,  606,  605,  604,
          603,  602,  601,  600,  599,  598,  597,  596,  595,  594,
          593,  592,  588,  587,  586,  585,  583,  581,  579,  578,
          577,  576,  574,  573,  572,  571,  570,  569,  568,  566,
          564,  563,  561,  559,  556,  555,  553,  552,  551,  550,
          548,  547,  546,  545,  543,  542,  541,  540,  539,  538,
          537,  535,  534,  532,  531,  529,  524,  523,  521,  520,
    
          519,  517,  514,  513,  512,  510,  509,  508,  507,  506,
          505,  504,  503,  502,  501,  499,  498,  496,  495,  494,
          493,  492,  491,  490,  489,  488,  487,  486,  485,  484,
          483,  482,  481,  479,  478,  477,  475,  474,  473,  472,
          469,  468,  467,  466,  465,  462,  459,  458,  457,  456,
          455,  454,  453,  451,  448,  445,  443,  441,  440,  439,
          437,  436,  435,  432,  431,  430,  429,  427,  426,  425,
          423,  419,  418,  417,  416,  415,  414,  413,  412,  410,
          409,  408,  406,  405,  402,  400,  398,  394,  393,  392,
          391,  390,  389,  388,  386,  385,  384,  382,  381,  380,
    
          379,  378,  376,  374,  373,  371,  369,  368,  367,  365,
          364,  363,  361,  360,  358,  356,  353,  352,  350,  348,
          347,  346,  345,  344,  343,  342,  341,  340,  339,  338,
          337,  336,  335,  334,  333,  331,  330,  329,  328,  324,
          323,  321,  318,  317,  316,  315,  312,  311,  310,  309,
          308,  307,  305,  303,  302,  299,  298,  297,  296,  294,
          293,  292,  291,  290,  289,  288,  287,  286,  285,  284,
          281,  279,  278,  277,  276,  275,  274,  273,  270,  269,
          268,  266,  265,  263,  261,  260,  259,  258,  256,  255,
          254,  253,  251,  249,  248,  247,  246,  245,  243,  241,
    
          240,  239,  238,  236,  235,  234,  233,  225,  224,  223,
          222,  221,  220,  219,  218,  217,  215,  214,  213,  212,
          211,  210,  209,  208,  207,  206,  205,  204,  203,  202,
          201,  200,  199,  198,  197,  196,  195,  194,  193,  192,
          191,  190,  189,  188,  187,  186,  185,  184,  183,  182,
          181,  180,  179,  178,  177,  175,  174,  173,  172,  171,
          169,  168,  166,  165,  164,  163,  162,  161,  160,  159,
          157,  156,  155,  154,  153,  152,  151,  150,  149,  148,
          147,  146,  144,  143,  135,  134,  133,  132,  131,  130,
          129,  125,  124,  123,  121,  120,  119,  118,  117,  115,
    
          114,  110,  109,  108,  107,  106,  105,  104,  102,  100,
           99,   98,   96,   95,   94,   93,   92,   91,   90,   89,
           88,   87,   86,   85,   83,   82,   81,   80,   79,   77,
           75,   74,   73,   71,   70,   69,   68,   67,   66,   65,
           64,   52,   44,   43,   42,   41,   35,   32,   21,   20,
           19,   11,    9,    7,    3,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
    
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633,  633,  633,
          633,  633,  633,  633,  633,  633,  633,  633
        } ;
    
    static yy_state_type yy_last_accepting_state;
    static char *yy_last_accepting_cpos;
    
    extern int gmsh_yy_flex_debug;
    int gmsh_yy_flex_debug = 0;
    
    /* The intent behind this definition is that it'll catch
     * any uses of REJECT which flex missed.
     */
    #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
    char *gmsh_yytext;
    #line 1 "Gmsh.l"
    #line 2 "Gmsh.l"
    // Gmsh - Copyright (C) 1997-2009 C. Geuzaine, J.-F. Remacle
    //
    // See the LICENSE.txt file for license information. Please report all
    // bugs and problems to <gmsh@geuz.org>.
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    #include "GmshMessage.h"
    #include "Geo.h"
    #include "Gmsh.tab.hpp"
    
    void   parsestring(char endchar);
    char  *strsave(char *ptr);
    void   skipcomments(void);
    void   skipline(void);
    
    #define YY_INPUT(buf,result,max_size)					\
         {									\
           int c = '*', n;							\
           for ( n = 0; n < max_size &&					\
    	       (c = getc( gmsh_yyin )) != EOF && c != '\n'; ++n )		\
    	 buf[n] = (char) c;						\
           if ( c == '\n' ){						\
    	 buf[n++] = (char) c;						\
    	 gmsh_yylineno++;							\
           }								\
           if ( c == EOF && ferror( gmsh_yyin ) )				\
    	 Msg::Fatal("Input in flex scanner failed");			\
           result = n;							\
         }									\
    
    #if defined(WIN32)
    #define isatty(arg) -1
    #define YY_NO_UNISTD_H
    #endif
    
    #line 887 "Gmsh.yy.cpp"
    
    #define INITIAL 0
    
    #ifndef YY_NO_UNISTD_H
    /* Special case for "unistd.h", since it is non-ANSI. We include it way
     * down here because we want the user's section 1 to have been scanned first.
     * The user has a chance to override it with an option.
     */
    #include <unistd.h>
    #endif
    
    #ifndef YY_EXTRA_TYPE
    #define YY_EXTRA_TYPE void *
    #endif
    
    static int yy_init_globals (void );
    
    /* Macros after this point can all be overridden by user definitions in
     * section 1.
     */
    
    #ifndef YY_SKIP_YYWRAP
    #ifdef __cplusplus
    extern "C" int gmsh_yywrap (void );
    #else
    extern int gmsh_yywrap (void );
    #endif
    #endif
    
        static void yyunput (int c,char *buf_ptr  );
        
    #ifndef yytext_ptr
    static void yy_flex_strncpy (char *,yyconst char *,int );
    #endif
    
    #ifdef YY_NEED_STRLEN
    static int yy_flex_strlen (yyconst char * );
    #endif
    
    #ifndef YY_NO_INPUT
    
    #ifdef __cplusplus
    static int yyinput (void );
    #else
    static int input (void );
    #endif
    
    #endif
    
    /* Amount of stuff to slurp up with each read. */
    #ifndef YY_READ_BUF_SIZE
    #define YY_READ_BUF_SIZE 8192
    #endif
    
    /* Copy whatever the last rule matched to the standard output. */
    #ifndef ECHO
    /* This used to be an fputs(), but since the string might contain NUL's,
     * we now use fwrite().
     */
    #define ECHO (void) fwrite( gmsh_yytext, gmsh_yyleng, 1, gmsh_yyout )
    #endif
    
    /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
     * is returned in "result".
     */
    #ifndef YY_INPUT
    #define YY_INPUT(buf,result,max_size) \
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
    		{ \
    		int c = '*'; \
    		size_t n; \
    		for ( n = 0; n < max_size && \
    			     (c = getc( gmsh_yyin )) != EOF && c != '\n'; ++n ) \
    			buf[n] = (char) c; \
    		if ( c == '\n' ) \
    			buf[n++] = (char) c; \
    		if ( c == EOF && ferror( gmsh_yyin ) ) \
    			YY_FATAL_ERROR( "input in flex scanner failed" ); \
    		result = n; \
    		} \
    	else \
    		{ \
    		errno=0; \
    		while ( (result = fread(buf, 1, max_size, gmsh_yyin))==0 && ferror(gmsh_yyin)) \
    			{ \
    			if( errno != EINTR) \
    				{ \
    				YY_FATAL_ERROR( "input in flex scanner failed" ); \
    				break; \
    				} \
    			errno=0; \
    			clearerr(gmsh_yyin); \
    			} \
    		}\
    \
    
    #endif
    
    /* No semi-colon after return; correct usage is to write "yyterminate();" -
     * we don't want an extra ';' after the "return" because that will cause
     * some compilers to complain about unreachable statements.
     */
    #ifndef yyterminate
    #define yyterminate() return YY_NULL
    #endif
    
    /* Number of entries by which start-condition stack grows. */
    #ifndef YY_START_STACK_INCR
    #define YY_START_STACK_INCR 25
    #endif
    
    /* Report a fatal error. */
    #ifndef YY_FATAL_ERROR
    #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
    #endif
    
    /* end tables serialization structures and prototypes */
    
    /* Default declaration of generated scanner - a define so the user can
     * easily add parameters.
     */
    #ifndef YY_DECL
    #define YY_DECL_IS_OURS 1
    
    extern int gmsh_yylex (void);
    
    #define YY_DECL int gmsh_yylex (void)
    #endif /* !YY_DECL */
    
    /* Code executed at the beginning of each rule, after gmsh_yytext and gmsh_yyleng
     * have been set up.
     */
    #ifndef YY_USER_ACTION
    #define YY_USER_ACTION
    #endif
    
    /* Code executed at the end of each rule. */
    #ifndef YY_BREAK
    #define YY_BREAK break;
    #endif
    
    #define YY_RULE_SETUP \
    	YY_USER_ACTION
    
    /** The main scanner function which does all the work.
     */
    YY_DECL
    {
    	register yy_state_type yy_current_state;
    	register char *yy_cp, *yy_bp;
    	register int yy_act;
        
    #line 49 "Gmsh.l"
    
    
    #line 1043 "Gmsh.yy.cpp"
    
    	if ( !(yy_init) )
    		{
    		(yy_init) = 1;
    
    #ifdef YY_USER_INIT
    		YY_USER_INIT;
    #endif
    
    		if ( ! (yy_start) )
    			(yy_start) = 1;	/* first start state */
    
    		if ( ! gmsh_yyin )
    			gmsh_yyin = stdin;
    
    		if ( ! gmsh_yyout )
    			gmsh_yyout = stdout;
    
    		if ( ! YY_CURRENT_BUFFER ) {
    			gmsh_yyensure_buffer_stack ();
    			YY_CURRENT_BUFFER_LVALUE =
    				gmsh_yy_create_buffer(gmsh_yyin,YY_BUF_SIZE );
    		}
    
    		gmsh_yy_load_buffer_state( );
    		}
    
    	while ( 1 )		/* loops until end-of-file is reached */
    		{
    		yy_cp = (yy_c_buf_p);
    
    		/* Support of gmsh_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
    			{
    			register 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 >= 634 )
    					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_base[yy_current_state] != 756 );
    
    yy_find_action:
    		yy_act = yy_accept[yy_current_state];
    		if ( yy_act == 0 )
    			{ /* have to back up */
    			yy_cp = (yy_last_accepting_cpos);
    			yy_current_state = (yy_last_accepting_state);
    			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:
    /* rule 1 can match eol */
    YY_RULE_SETUP
    #line 51 "Gmsh.l"
    /* none */;
    	YY_BREAK
    case 2:
    YY_RULE_SETUP
    #line 52 "Gmsh.l"
    return tEND;
    	YY_BREAK
    case 3:
    YY_RULE_SETUP
    #line 53 "Gmsh.l"
    skipcomments();
    	YY_BREAK
    case 4:
    YY_RULE_SETUP
    #line 54 "Gmsh.l"
    skipline();
    	YY_BREAK
    case 5:
    YY_RULE_SETUP
    #line 55 "Gmsh.l"
    { parsestring('\"'); return tBIGSTR; }
    	YY_BREAK
    case 6:
    YY_RULE_SETUP
    #line 56 "Gmsh.l"
    { parsestring('\''); return tBIGSTR; }
    	YY_BREAK
    case 7:
    YY_RULE_SETUP
    #line 57 "Gmsh.l"
    { gmsh_yylval.d = NEWREG(); return tDOUBLE; }
    	YY_BREAK
    case 8:
    YY_RULE_SETUP
    #line 58 "Gmsh.l"
    { gmsh_yylval.d = NEWPOINT(); return tDOUBLE; }
    	YY_BREAK
    case 9:
    YY_RULE_SETUP
    #line 59 "Gmsh.l"
    { gmsh_yylval.d = NEWLINE(); return tDOUBLE; }
    	YY_BREAK
    case 10:
    YY_RULE_SETUP
    #line 60 "Gmsh.l"
    { gmsh_yylval.d = NEWLINE(); return tDOUBLE; }
    	YY_BREAK
    case 11:
    YY_RULE_SETUP
    #line 61 "Gmsh.l"
    { gmsh_yylval.d = NEWLINELOOP(); return tDOUBLE; }
    	YY_BREAK
    case 12:
    YY_RULE_SETUP
    #line 62 "Gmsh.l"
    { gmsh_yylval.d = NEWSURFACE(); return tDOUBLE; }
    	YY_BREAK
    case 13:
    YY_RULE_SETUP
    #line 63 "Gmsh.l"
    { gmsh_yylval.d = NEWSURFACELOOP(); return tDOUBLE; }
    	YY_BREAK
    case 14:
    YY_RULE_SETUP
    #line 64 "Gmsh.l"
    { gmsh_yylval.d = NEWVOLUME(); return tDOUBLE; }
    	YY_BREAK
    case 15:
    YY_RULE_SETUP
    #line 65 "Gmsh.l"
    { gmsh_yylval.d = NEWFIELD(); return tDOUBLE; }
    	YY_BREAK
    case 16:
    YY_RULE_SETUP
    #line 66 "Gmsh.l"
    return tAFFECT;
    	YY_BREAK
    case 17:
    YY_RULE_SETUP
    #line 67 "Gmsh.l"
    return tAFFECTPLUS;
    	YY_BREAK
    case 18:
    YY_RULE_SETUP
    #line 68 "Gmsh.l"
    return tAFFECTMINUS;
    	YY_BREAK
    case 19:
    YY_RULE_SETUP
    #line 69 "Gmsh.l"
    return tAFFECTTIMES;
    	YY_BREAK
    case 20:
    YY_RULE_SETUP
    #line 70 "Gmsh.l"
    return tAFFECTDIVIDE;
    	YY_BREAK
    case 21:
    YY_RULE_SETUP
    #line 71 "Gmsh.l"
    return tDOTS;
    	YY_BREAK
    case 22:
    YY_RULE_SETUP
    #line 72 "Gmsh.l"
    return tDOTS;
    	YY_BREAK
    case 23:
    YY_RULE_SETUP
    #line 73 "Gmsh.l"
    return tOR;
    	YY_BREAK
    case 24:
    YY_RULE_SETUP
    #line 74 "Gmsh.l"
    return tAND;
    	YY_BREAK
    case 25:
    YY_RULE_SETUP
    #line 75 "Gmsh.l"
    return tPLUSPLUS;
    	YY_BREAK
    case 26:
    YY_RULE_SETUP
    #line 76 "Gmsh.l"
    return tMINUSMINUS;
    	YY_BREAK
    case 27:
    YY_RULE_SETUP
    #line 77 "Gmsh.l"
    return tEQUAL;
    	YY_BREAK
    case 28:
    YY_RULE_SETUP
    #line 78 "Gmsh.l"
    return tNOTEQUAL;
    	YY_BREAK
    case 29:
    YY_RULE_SETUP
    #line 79 "Gmsh.l"
    return tLESSOREQUAL;
    	YY_BREAK
    case 30:
    YY_RULE_SETUP
    #line 80 "Gmsh.l"
    return tGREATEROREQUAL;
    	YY_BREAK
    case 31:
    YY_RULE_SETUP
    #line 82 "Gmsh.l"
    return tAcos;
    	YY_BREAK
    case 32:
    YY_RULE_SETUP
    #line 83 "Gmsh.l"
    return tAcos;
    	YY_BREAK
    case 33:
    YY_RULE_SETUP
    #line 84 "Gmsh.l"
    return tAlias;
    	YY_BREAK
    case 34:
    YY_RULE_SETUP
    #line 85 "Gmsh.l"
    return tAliasWithOptions;
    	YY_BREAK
    case 35:
    YY_RULE_SETUP
    #line 86 "Gmsh.l"
    return tAsin;
    	YY_BREAK
    case 36:
    YY_RULE_SETUP
    #line 87 "Gmsh.l"
    return tAsin;
    	YY_BREAK
    case 37:
    YY_RULE_SETUP
    #line 88 "Gmsh.l"
    return tAtan;
    	YY_BREAK
    case 38:
    YY_RULE_SETUP
    #line 89 "Gmsh.l"
    return tAtan;
    	YY_BREAK
    case 39:
    YY_RULE_SETUP
    #line 90 "Gmsh.l"
    return tAtan2;
    	YY_BREAK
    case 40:
    YY_RULE_SETUP
    #line 91 "Gmsh.l"
    return tAtan2;
    	YY_BREAK
    case 41:
    YY_RULE_SETUP
    #line 93 "Gmsh.l"
    return tBezier;
    	YY_BREAK
    case 42:
    YY_RULE_SETUP
    #line 94 "Gmsh.l"
    return tBSpline;
    	YY_BREAK
    case 43:
    YY_RULE_SETUP
    #line 95 "Gmsh.l"
    return tBoundingBox;
    	YY_BREAK
    case 44:
    YY_RULE_SETUP
    #line 97 "Gmsh.l"
    return tCeil;
    	YY_BREAK
    case 45:
    YY_RULE_SETUP
    #line 98 "Gmsh.l"
    return tCircle;
    	YY_BREAK
    case 46:
    YY_RULE_SETUP
    #line 99 "Gmsh.l"
    return tCoherence;
    	YY_BREAK
    case 47:
    YY_RULE_SETUP
    #line 100 "Gmsh.l"
    return tCombine;
    	YY_BREAK
    case 48:
    YY_RULE_SETUP
    #line 101 "Gmsh.l"
    return tCosh;
    	YY_BREAK
    case 49:
    YY_RULE_SETUP
    #line 102 "Gmsh.l"
    return tCos;
    	YY_BREAK
    case 50:
    YY_RULE_SETUP
    #line 103 "Gmsh.l"
    return tCharacteristic;
    	YY_BREAK
    case 51:
    YY_RULE_SETUP
    #line 104 "Gmsh.l"
    return tComplex;
    	YY_BREAK
    case 52:
    YY_RULE_SETUP
    #line 105 "Gmsh.l"
    return tColor;
    	YY_BREAK
    case 53:
    YY_RULE_SETUP
    #line 106 "Gmsh.l"
    return tColorTable;
    	YY_BREAK
    case 54:
    YY_RULE_SETUP
    #line 107 "Gmsh.l"
    return tCompound;
    	YY_BREAK
    case 55:
    YY_RULE_SETUP
    #line 108 "Gmsh.l"
    return tCoordinates;
    	YY_BREAK
    case 56:
    YY_RULE_SETUP
    #line 109 "Gmsh.l"
    return tSpline;
    	YY_BREAK
    case 57:
    YY_RULE_SETUP
    #line 110 "Gmsh.l"
    return tCall;
    	YY_BREAK
    case 58:
    YY_RULE_SETUP
    #line 111 "Gmsh.l"
    return tCreateTopology;
    	YY_BREAK
    case 59:
    YY_RULE_SETUP
    #line 113 "Gmsh.l"
    return tDelete;
    	YY_BREAK
    case 60:
    YY_RULE_SETUP
    #line 114 "Gmsh.l"
    return tDegenerated;
    	YY_BREAK
    case 61:
    YY_RULE_SETUP
    #line 115 "Gmsh.l"
    return tDilate;
    	YY_BREAK
    case 62:
    YY_RULE_SETUP
    #line 116 "Gmsh.l"
    return tDraw;
    	YY_BREAK
    case 63:
    YY_RULE_SETUP
    #line 118 "Gmsh.l"
    return tExp;
    	YY_BREAK
    case 64:
    YY_RULE_SETUP
    #line 119 "Gmsh.l"
    return tEllipse;
    	YY_BREAK
    case 65:
    YY_RULE_SETUP
    #line 120 "Gmsh.l"
    return tEllipse;
    	YY_BREAK
    case 66:
    YY_RULE_SETUP
    #line 121 "Gmsh.l"
    return tExtrude;
    	YY_BREAK
    case 67:
    YY_RULE_SETUP
    #line 122 "Gmsh.l"
    return tElliptic;
    	YY_BREAK
    case 68:
    YY_RULE_SETUP
    #line 123 "Gmsh.l"
    return tEndFor;
    	YY_BREAK
    case 69:
    YY_RULE_SETUP
    #line 124 "Gmsh.l"
    return tEndIf;
    	YY_BREAK
    case 70:
    YY_RULE_SETUP
    #line 125 "Gmsh.l"
    return tEuclidian;
    	YY_BREAK
    case 71:
    YY_RULE_SETUP
    #line 126 "Gmsh.l"
    return tExit;
    	YY_BREAK
    case 72:
    YY_RULE_SETUP
    #line 128 "Gmsh.l"
    return tFabs;
    	YY_BREAK
    case 73:
    YY_RULE_SETUP
    #line 129 "Gmsh.l"
    return tField;
    	YY_BREAK
    case 74:
    YY_RULE_SETUP
    #line 130 "Gmsh.l"
    return tFloor;
    	YY_BREAK
    case 75:
    YY_RULE_SETUP
    #line 131 "Gmsh.l"
    return tFmod;
    	YY_BREAK
    case 76:
    YY_RULE_SETUP
    #line 132 "Gmsh.l"
    return tFor;
    	YY_BREAK
    case 77:
    YY_RULE_SETUP
    #line 133 "Gmsh.l"
    return tFunction;
    	YY_BREAK
    case 78:
    YY_RULE_SETUP
    #line 135 "Gmsh.l"
    return tGetValue;
    	YY_BREAK
    case 79:
    YY_RULE_SETUP
    #line 136 "Gmsh.l"
    return tGMSH_MAJOR_VERSION;
    	YY_BREAK
    case 80:
    YY_RULE_SETUP
    #line 137 "Gmsh.l"
    return tGMSH_MINOR_VERSION;
    	YY_BREAK
    case 81:
    YY_RULE_SETUP
    #line 138 "Gmsh.l"
    return tGMSH_PATCH_VERSION;
    	YY_BREAK
    case 82:
    YY_RULE_SETUP
    #line 140 "Gmsh.l"
    return tHide;
    	YY_BREAK
    case 83:
    YY_RULE_SETUP
    #line 141 "Gmsh.l"
    return tHole;
    	YY_BREAK
    case 84:
    YY_RULE_SETUP
    #line 142 "Gmsh.l"
    return tHypot;
    	YY_BREAK
    case 85:
    YY_RULE_SETUP
    #line 144 "Gmsh.l"
    return tIn;
    	YY_BREAK
    case 86:
    YY_RULE_SETUP
    #line 145 "Gmsh.l"
    return tIf;
    	YY_BREAK
    case 87:
    YY_RULE_SETUP
    #line 146 "Gmsh.l"
    return tIntersect;
    	YY_BREAK
    case 88:
    YY_RULE_SETUP
    #line 147 "Gmsh.l"
    return tInterpolationScheme;
    	YY_BREAK
    case 89:
    YY_RULE_SETUP
    #line 149 "Gmsh.l"
    return tNurbsKnots;
    	YY_BREAK
    case 90:
    YY_RULE_SETUP
    #line 151 "Gmsh.l"
    return tLength;
    	YY_BREAK
    case 91:
    YY_RULE_SETUP
    #line 152 "Gmsh.l"
    return tLine;
    	YY_BREAK
    case 92:
    YY_RULE_SETUP
    #line 153 "Gmsh.l"
    return tLoop;
    	YY_BREAK
    case 93:
    YY_RULE_SETUP
    #line 154 "Gmsh.l"
    return tLog;
    	YY_BREAK
    case 94:
    YY_RULE_SETUP
    #line 155 "Gmsh.l"
    return tLog10;
    	YY_BREAK
    case 95:
    YY_RULE_SETUP
    #line 156 "Gmsh.l"
    return tLayers;
    	YY_BREAK
    case 96:
    YY_RULE_SETUP
    #line 157 "Gmsh.l"
    return tLevelset;
    	YY_BREAK
    case 97:
    YY_RULE_SETUP
    #line 159 "Gmsh.l"
    return tModulo;
    	YY_BREAK
    case 98:
    YY_RULE_SETUP
    #line 160 "Gmsh.l"
    return tMPI_Rank;
    	YY_BREAK
    case 99:
    YY_RULE_SETUP
    #line 161 "Gmsh.l"
    return tMPI_Size;
    	YY_BREAK
    case 100:
    YY_RULE_SETUP
    #line 163 "Gmsh.l"
    return tNurbs;
    	YY_BREAK
    case 101:
    YY_RULE_SETUP
    #line 165 "Gmsh.l"
    return tNurbsOrder;
    	YY_BREAK
    case 102:
    YY_RULE_SETUP
    #line 166 "Gmsh.l"
    return tOCCShape;
    	YY_BREAK
    case 103:
    YY_RULE_SETUP
    #line 168 "Gmsh.l"
    return tPhysical;
    	YY_BREAK
    case 104:
    YY_RULE_SETUP
    #line 169 "Gmsh.l"
    return tPi;
    	YY_BREAK
    case 105:
    YY_RULE_SETUP
    #line 170 "Gmsh.l"
    return tPlane;
    	YY_BREAK
    case 106:
    YY_RULE_SETUP
    #line 171 "Gmsh.l"
    return tPoint;
    	YY_BREAK
    case 107:
    YY_RULE_SETUP
    #line 172 "Gmsh.l"
    return tParametric;
    	YY_BREAK
    case 108:
    YY_RULE_SETUP
    #line 173 "Gmsh.l"
    return tPolarSphere;
    	YY_BREAK
    case 109:
    YY_RULE_SETUP
    #line 174 "Gmsh.l"
    return tPrintf;
    	YY_BREAK
    case 110:
    YY_RULE_SETUP
    #line 175 "Gmsh.l"
    return tPlugin;
    	YY_BREAK
    case 111:
    YY_RULE_SETUP
    #line 177 "Gmsh.l"
    return tRecombine;
    	YY_BREAK
    case 112:
    YY_RULE_SETUP
    #line 178 "Gmsh.l"
    return tRotate;
    	YY_BREAK
    case 113:
    YY_RULE_SETUP
    #line 179 "Gmsh.l"
    return tRuled;
    	YY_BREAK
    case 114:
    YY_RULE_SETUP
    #line 180 "Gmsh.l"
    return tRand;
    	YY_BREAK
    case 115:
    YY_RULE_SETUP
    #line 181 "Gmsh.l"
    return tReturn;
    	YY_BREAK
    case 116:
    YY_RULE_SETUP
    #line 183 "Gmsh.l"
    return tSmoother;
    	YY_BREAK
    case 117:
    YY_RULE_SETUP
    #line 184 "Gmsh.l"
    return tSqrt;
    	YY_BREAK
    case 118:
    YY_RULE_SETUP
    #line 185 "Gmsh.l"
    return tSin;
    	YY_BREAK
    case 119:
    YY_RULE_SETUP
    #line 186 "Gmsh.l"
    return tSinh;
    	YY_BREAK
    case 120:
    YY_RULE_SETUP
    #line 187 "Gmsh.l"
    return tSphere;
    	YY_BREAK
    case 121:
    YY_RULE_SETUP
    #line 188 "Gmsh.l"
    return tSpline;
    	YY_BREAK
    case 122:
    YY_RULE_SETUP
    #line 189 "Gmsh.l"
    return tSplit;
    	YY_BREAK
    case 123:
    YY_RULE_SETUP
    #line 190 "Gmsh.l"
    return tSurface;
    	YY_BREAK
    case 124:
    YY_RULE_SETUP
    #line 191 "Gmsh.l"
    return tSprintf;
    	YY_BREAK
    case 125:
    YY_RULE_SETUP
    #line 192 "Gmsh.l"
    return tStrCat;
    	YY_BREAK
    case 126:
    YY_RULE_SETUP
    #line 193 "Gmsh.l"
    return tStrPrefix;
    	YY_BREAK
    case 127:
    YY_RULE_SETUP
    #line 194 "Gmsh.l"
    return tStrRelative;
    	YY_BREAK
    case 128:
    YY_RULE_SETUP
    #line 195 "Gmsh.l"
    return tShow;
    	YY_BREAK
    case 129:
    YY_RULE_SETUP
    #line 196 "Gmsh.l"
    return tSymmetry;
    	YY_BREAK
    case 130:
    YY_RULE_SETUP
    #line 197 "Gmsh.l"
    return tSyncModel;
    	YY_BREAK
    case 131:
    YY_RULE_SETUP
    #line 199 "Gmsh.l"
    return tText2D;
    	YY_BREAK
    case 132:
    YY_RULE_SETUP
    #line 200 "Gmsh.l"
    return tText3D;
    	YY_BREAK
    case 133:
    YY_RULE_SETUP
    #line 201 "Gmsh.l"
    return tTime;
    	YY_BREAK
    case 134:
    YY_RULE_SETUP
    #line 202 "Gmsh.l"
    return tTransfinite;
    	YY_BREAK
    case 135:
    YY_RULE_SETUP
    #line 203 "Gmsh.l"
    return tTranslate;
    	YY_BREAK
    case 136:
    YY_RULE_SETUP
    #line 204 "Gmsh.l"
    return tTanh;
    	YY_BREAK
    case 137:
    YY_RULE_SETUP
    #line 205 "Gmsh.l"
    return tTan;
    	YY_BREAK
    case 138:
    YY_RULE_SETUP
    #line 206 "Gmsh.l"
    return tToday;
    	YY_BREAK
    case 139:
    YY_RULE_SETUP
    #line 208 "Gmsh.l"
    return tUsing;
    	YY_BREAK
    case 140:
    YY_RULE_SETUP
    #line 210 "Gmsh.l"
    return tVolume;
    	YY_BREAK
    case 141:
    #line 213 "Gmsh.l"
    case 142:
    #line 214 "Gmsh.l"
    case 143:
    #line 215 "Gmsh.l"
    case 144:
    YY_RULE_SETUP
    #line 215 "Gmsh.l"
    { gmsh_yylval.d = atof((char *)gmsh_yytext); return tDOUBLE; }
    	YY_BREAK
    case 145:
    YY_RULE_SETUP
    #line 217 "Gmsh.l"
    { gmsh_yylval.c = strsave((char*)gmsh_yytext); return tSTRING; }
    	YY_BREAK
    case 146:
    YY_RULE_SETUP
    #line 219 "Gmsh.l"
    return gmsh_yytext[0];
    	YY_BREAK
    case 147:
    YY_RULE_SETUP
    #line 221 "Gmsh.l"
    ECHO;
    	YY_BREAK
    #line 1853 "Gmsh.yy.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 gmsh_yyin at a new source and called
    			 * gmsh_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 = gmsh_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_c_buf_p);
    				goto yy_find_action;
    				}
    			}
    
    		else switch ( yy_get_next_buffer(  ) )
    			{
    			case EOB_ACT_END_OF_FILE:
    				{
    				(yy_did_buffer_switch_on_eof) = 0;
    
    				if ( gmsh_yywrap( ) )
    					{
    					/* Note: because we've taken care in
    					 * yy_get_next_buffer() to have set up
    					 * gmsh_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 */
    } /* end of gmsh_yylex */
    
    /* yy_get_next_buffer - try to read in a new buffer
     *
     * Returns a code representing an action:
     *	EOB_ACT_LAST_MATCH -
     *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
     *	EOB_ACT_END_OF_FILE - end of file
     */
    static int yy_get_next_buffer (void)
    {
        	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    	register char *source = (yytext_ptr);
    	register int number_to_move, i;
    	int ret_val;
    
    	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    		YY_FATAL_ERROR(
    		"fatal flex scanner internal error--end of buffer missed" );
    
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    		{ /* Don't try to fill the buffer, so this is an EOF. */
    		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    			{
    			/* We matched a single character, the EOB, so
    			 * treat this as a final EOF.
    			 */
    			return EOB_ACT_END_OF_FILE;
    			}
    
    		else
    			{
    			/* We matched some text prior to the EOB, first
    			 * process it.
    			 */
    			return EOB_ACT_LAST_MATCH;
    			}
    		}
    
    	/* Try to read more data. */
    
    	/* First move last chars to start of buffer. */
    	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
    
    	for ( i = 0; i < number_to_move; ++i )
    		*(dest++) = *(source++);
    
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    		/* don't do the read, it's not guaranteed to return an EOF,
    		 * just force an EOF
    		 */
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    
    	else
    		{
    			int num_to_read =
    			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    
    		while ( num_to_read <= 0 )
    			{ /* Not enough room in the buffer - grow it. */
    
    			/* just a shorter name for the current buffer */
    			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    
    			int yy_c_buf_p_offset =
    				(int) ((yy_c_buf_p) - b->yy_ch_buf);
    
    			if ( b->yy_is_our_buffer )
    				{
    				int new_size = b->yy_buf_size * 2;
    
    				if ( new_size <= 0 )
    					b->yy_buf_size += b->yy_buf_size / 8;
    				else
    					b->yy_buf_size *= 2;
    
    				b->yy_ch_buf = (char *)
    					/* Include room in for 2 EOB chars. */
    					gmsh_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
    				}
    			else
    				/* Can't grow it, we don't own it. */
    				b->yy_ch_buf = 0;
    
    			if ( ! b->yy_ch_buf )
    				YY_FATAL_ERROR(
    				"fatal error - scanner input buffer overflow" );
    
    			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
    
    			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    						number_to_move - 1;
    
    			}
    
    		if ( num_to_read > YY_READ_BUF_SIZE )
    			num_to_read = YY_READ_BUF_SIZE;
    
    		/* Read in more data. */
    		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    			(yy_n_chars), num_to_read );
    
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	if ( (yy_n_chars) == 0 )
    		{
    		if ( number_to_move == YY_MORE_ADJ )
    			{
    			ret_val = EOB_ACT_END_OF_FILE;
    			gmsh_yyrestart(gmsh_yyin  );
    			}
    
    		else
    			{
    			ret_val = EOB_ACT_LAST_MATCH;
    			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    				YY_BUFFER_EOF_PENDING;
    			}
    		}
    
    	else
    		ret_val = EOB_ACT_CONTINUE_SCAN;
    
    	(yy_n_chars) += number_to_move;
    	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
    
    	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    
    	return ret_val;
    }
    
    /* yy_get_previous_state - get the state just before the EOB char was reached */
    
        static yy_state_type yy_get_previous_state (void)
    {
    	register yy_state_type yy_current_state;
    	register char *yy_cp;
        
    	yy_current_state = (yy_start);
    
    	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    		{
    		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    		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 >= 634 )
    				yy_c = yy_meta[(unsigned int) yy_c];
    			}
    		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    		}
    
    	return yy_current_state;
    }
    
    /* yy_try_NUL_trans - try to make a transition on the NUL character
     *
     * synopsis
     *	next_state = yy_try_NUL_trans( current_state );
     */
        static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
    {
    	register int yy_is_jam;
        	register char *yy_cp = (yy_c_buf_p);
    
    	register YY_CHAR yy_c = 1;
    	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 >= 634 )
    			yy_c = yy_meta[(unsigned int) yy_c];
    		}
    	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    	yy_is_jam = (yy_current_state == 633);
    
    	return yy_is_jam ? 0 : yy_current_state;
    }
    
        static void yyunput (int c, register char * yy_bp )
    {
    	register char *yy_cp;
        
        yy_cp = (yy_c_buf_p);
    
    	/* undo effects of setting up gmsh_yytext */
    	*yy_cp = (yy_hold_char);
    
    	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    		{ /* need to shift things up to make room */
    		/* +2 for EOB chars. */
    		register int number_to_move = (yy_n_chars) + 2;
    		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    		register char *source =
    				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    
    		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    			*--dest = *--source;
    
    		yy_cp += (int) (dest - source);
    		yy_bp += (int) (dest - source);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    
    		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    			YY_FATAL_ERROR( "flex scanner push-back overflow" );
    		}
    
    	*--yy_cp = (char) c;
    
    	(yytext_ptr) = yy_bp;
    	(yy_hold_char) = *yy_cp;
    	(yy_c_buf_p) = yy_cp;
    }
    
    #ifndef YY_NO_INPUT
    #ifdef __cplusplus
        static int yyinput (void)
    #else
        static int input  (void)
    #endif
    
    {
    	int c;
        
    	*(yy_c_buf_p) = (yy_hold_char);
    
    	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    		{
    		/* yy_c_buf_p now points to the character we want to return.
    		 * If this occurs *before* the EOB characters, then it's a
    		 * valid NUL; if not, then we've hit the end of the buffer.
    		 */
    		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    			/* This was really a NUL. */
    			*(yy_c_buf_p) = '\0';
    
    		else
    			{ /* need more input */
    			int offset = (yy_c_buf_p) - (yytext_ptr);
    			++(yy_c_buf_p);
    
    			switch ( yy_get_next_buffer(  ) )
    				{
    				case EOB_ACT_LAST_MATCH:
    					/* This happens because yy_g_n_b()
    					 * sees that we've accumulated a
    					 * token and flags that we need to
    					 * try matching the token before
    					 * proceeding.  But for input(),
    					 * there's no matching to consider.
    					 * So convert the EOB_ACT_LAST_MATCH
    					 * to EOB_ACT_END_OF_FILE.
    					 */
    
    					/* Reset buffer status. */
    					gmsh_yyrestart(gmsh_yyin );
    
    					/*FALLTHROUGH*/
    
    				case EOB_ACT_END_OF_FILE:
    					{
    					if ( gmsh_yywrap( ) )
    						return 0;
    
    					if ( ! (yy_did_buffer_switch_on_eof) )
    						YY_NEW_FILE;
    #ifdef __cplusplus
    					return yyinput();
    #else
    					return input();
    #endif
    					}
    
    				case EOB_ACT_CONTINUE_SCAN:
    					(yy_c_buf_p) = (yytext_ptr) + offset;
    					break;
    				}
    			}
    		}
    
    	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
    	*(yy_c_buf_p) = '\0';	/* preserve gmsh_yytext */
    	(yy_hold_char) = *++(yy_c_buf_p);
    
    	return c;
    }
    #endif	/* ifndef YY_NO_INPUT */
    
    /** Immediately switch to a different input stream.
     * @param input_file A readable stream.
     * 
     * @note This function does not reset the start condition to @c INITIAL .
     */
        void gmsh_yyrestart  (FILE * input_file )
    {
        
    	if ( ! YY_CURRENT_BUFFER ){
            gmsh_yyensure_buffer_stack ();
    		YY_CURRENT_BUFFER_LVALUE =
                gmsh_yy_create_buffer(gmsh_yyin,YY_BUF_SIZE );
    	}
    
    	gmsh_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
    	gmsh_yy_load_buffer_state( );
    }
    
    /** Switch to a different input buffer.
     * @param new_buffer The new input buffer.
     * 
     */
        void gmsh_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
    {
        
    	/* TODO. We should be able to replace this entire function body
    	 * with
    	 *		gmsh_yypop_buffer_state();
    	 *		gmsh_yypush_buffer_state(new_buffer);
         */
    	gmsh_yyensure_buffer_stack ();
    	if ( YY_CURRENT_BUFFER == new_buffer )
    		return;
    
    	if ( YY_CURRENT_BUFFER )
    		{
    		/* Flush out information for old buffer. */
    		*(yy_c_buf_p) = (yy_hold_char);
    		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	YY_CURRENT_BUFFER_LVALUE = new_buffer;
    	gmsh_yy_load_buffer_state( );
    
    	/* We don't actually know whether we did this switch during
    	 * EOF (gmsh_yywrap()) processing, but the only time this flag
    	 * is looked at is after gmsh_yywrap() is called, so it's safe
    	 * to go ahead and always set it.
    	 */
    	(yy_did_buffer_switch_on_eof) = 1;
    }
    
    static void gmsh_yy_load_buffer_state  (void)
    {
        	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    	gmsh_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    	(yy_hold_char) = *(yy_c_buf_p);
    }
    
    /** Allocate and initialize an input buffer state.
     * @param file A readable stream.
     * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
     * 
     * @return the allocated buffer state.
     */
        YY_BUFFER_STATE gmsh_yy_create_buffer  (FILE * file, int  size )
    {
    	YY_BUFFER_STATE b;
        
    	b = (YY_BUFFER_STATE) gmsh_yyalloc(sizeof( struct yy_buffer_state )  );
    	if ( ! b )
    		YY_FATAL_ERROR( "out of dynamic memory in gmsh_yy_create_buffer()" );
    
    	b->yy_buf_size = size;
    
    	/* yy_ch_buf has to be 2 characters longer than the size given because
    	 * we need to put in 2 end-of-buffer characters.
    	 */
    	b->yy_ch_buf = (char *) gmsh_yyalloc(b->yy_buf_size + 2  );
    	if ( ! b->yy_ch_buf )
    		YY_FATAL_ERROR( "out of dynamic memory in gmsh_yy_create_buffer()" );
    
    	b->yy_is_our_buffer = 1;
    
    	gmsh_yy_init_buffer(b,file );
    
    	return b;
    }
    
    /** Destroy the buffer.
     * @param b a buffer created with gmsh_yy_create_buffer()
     * 
     */
        void gmsh_yy_delete_buffer (YY_BUFFER_STATE  b )
    {
        
    	if ( ! b )
    		return;
    
    	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    
    	if ( b->yy_is_our_buffer )
    		gmsh_yyfree((void *) b->yy_ch_buf  );
    
    	gmsh_yyfree((void *) b  );
    }
    
    #ifndef __cplusplus
    extern int isatty (int );
    #endif /* __cplusplus */
        
    /* Initializes or reinitializes a buffer.
     * This function is sometimes called more than once on the same buffer,
     * such as during a gmsh_yyrestart() or at EOF.
     */
        static void gmsh_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
    
    {
    	int oerrno = errno;
        
    	gmsh_yy_flush_buffer(b );
    
    	b->yy_input_file = file;
    	b->yy_fill_buffer = 1;
    
        /* If b is the current buffer, then gmsh_yy_init_buffer was _probably_
         * called from gmsh_yyrestart() or through yy_get_next_buffer.
         * In that case, we don't want to reset the lineno or column.
         */
        if (b != YY_CURRENT_BUFFER){
            b->yy_bs_lineno = 1;
            b->yy_bs_column = 0;
        }
    
            b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
        
    	errno = oerrno;
    }
    
    /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
     * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
     * 
     */
        void gmsh_yy_flush_buffer (YY_BUFFER_STATE  b )
    {
        	if ( ! b )
    		return;
    
    	b->yy_n_chars = 0;
    
    	/* We always need two end-of-buffer characters.  The first causes
    	 * a transition to the end-of-buffer state.  The second causes
    	 * a jam in that state.
    	 */
    	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    
    	b->yy_buf_pos = &b->yy_ch_buf[0];
    
    	b->yy_at_bol = 1;
    	b->yy_buffer_status = YY_BUFFER_NEW;
    
    	if ( b == YY_CURRENT_BUFFER )
    		gmsh_yy_load_buffer_state( );
    }
    
    /** Pushes the new state onto the stack. The new state becomes
     *  the current state. This function will allocate the stack
     *  if necessary.
     *  @param new_buffer The new state.
     *  
     */
    void gmsh_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
    {
        	if (new_buffer == NULL)
    		return;
    
    	gmsh_yyensure_buffer_stack();
    
    	/* This block is copied from gmsh_yy_switch_to_buffer. */
    	if ( YY_CURRENT_BUFFER )
    		{
    		/* Flush out information for old buffer. */
    		*(yy_c_buf_p) = (yy_hold_char);
    		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	/* Only push if top exists. Otherwise, replace top. */
    	if (YY_CURRENT_BUFFER)
    		(yy_buffer_stack_top)++;
    	YY_CURRENT_BUFFER_LVALUE = new_buffer;
    
    	/* copied from gmsh_yy_switch_to_buffer. */
    	gmsh_yy_load_buffer_state( );
    	(yy_did_buffer_switch_on_eof) = 1;
    }
    
    /** Removes and deletes the top of the stack, if present.
     *  The next element becomes the new top.
     *  
     */
    void gmsh_yypop_buffer_state (void)
    {
        	if (!YY_CURRENT_BUFFER)
    		return;
    
    	gmsh_yy_delete_buffer(YY_CURRENT_BUFFER );
    	YY_CURRENT_BUFFER_LVALUE = NULL;
    	if ((yy_buffer_stack_top) > 0)
    		--(yy_buffer_stack_top);
    
    	if (YY_CURRENT_BUFFER) {
    		gmsh_yy_load_buffer_state( );
    		(yy_did_buffer_switch_on_eof) = 1;
    	}
    }
    
    /* Allocates the stack if it does not exist.
     *  Guarantees space for at least one push.
     */
    static void gmsh_yyensure_buffer_stack (void)
    {
    	int num_to_alloc;
        
    	if (!(yy_buffer_stack)) {
    
    		/* First allocation is just for 2 elements, since we don't know if this
    		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
    		 * immediate realloc on the next call.
             */
    		num_to_alloc = 1;
    		(yy_buffer_stack) = (struct yy_buffer_state**)gmsh_yyalloc
    								(num_to_alloc * sizeof(struct yy_buffer_state*)
    								);
    		
    		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    				
    		(yy_buffer_stack_max) = num_to_alloc;
    		(yy_buffer_stack_top) = 0;
    		return;
    	}
    
    	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
    
    		/* Increase the buffer to prepare for a possible push. */
    		int grow_size = 8 /* arbitrary grow size */;
    
    		num_to_alloc = (yy_buffer_stack_max) + grow_size;
    		(yy_buffer_stack) = (struct yy_buffer_state**)gmsh_yyrealloc
    								((yy_buffer_stack),
    								num_to_alloc * sizeof(struct yy_buffer_state*)
    								);
    
    		/* zero only the new slots.*/
    		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
    		(yy_buffer_stack_max) = num_to_alloc;
    	}
    }
    
    /** Setup the input buffer state to scan directly from a user-specified character buffer.
     * @param base the character buffer
     * @param size the size in bytes of the character buffer
     * 
     * @return the newly allocated buffer state object. 
     */
    YY_BUFFER_STATE gmsh_yy_scan_buffer  (char * base, yy_size_t  size )
    {
    	YY_BUFFER_STATE b;
        
    	if ( size < 2 ||
    	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
    	     base[size-1] != YY_END_OF_BUFFER_CHAR )
    		/* They forgot to leave room for the EOB's. */
    		return 0;
    
    	b = (YY_BUFFER_STATE) gmsh_yyalloc(sizeof( struct yy_buffer_state )  );
    	if ( ! b )
    		YY_FATAL_ERROR( "out of dynamic memory in gmsh_yy_scan_buffer()" );
    
    	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
    	b->yy_buf_pos = b->yy_ch_buf = base;
    	b->yy_is_our_buffer = 0;
    	b->yy_input_file = 0;
    	b->yy_n_chars = b->yy_buf_size;
    	b->yy_is_interactive = 0;
    	b->yy_at_bol = 1;
    	b->yy_fill_buffer = 0;
    	b->yy_buffer_status = YY_BUFFER_NEW;
    
    	gmsh_yy_switch_to_buffer(b  );
    
    	return b;
    }
    
    /** Setup the input buffer state to scan a string. The next call to gmsh_yylex() will
     * scan from a @e copy of @a str.
     * @param str a NUL-terminated string to scan
     * 
     * @return the newly allocated buffer state object.
     * @note If you want to scan bytes that may contain NUL values, then use
     *       gmsh_yy_scan_bytes() instead.
     */
    YY_BUFFER_STATE gmsh_yy_scan_string (yyconst char * yystr )
    {
        
    	return gmsh_yy_scan_bytes(yystr,strlen(yystr) );
    }
    
    /** Setup the input buffer state to scan the given bytes. The next call to gmsh_yylex() will
     * scan from a @e copy of @a bytes.
     * @param bytes the byte buffer to scan
     * @param len the number of bytes in the buffer pointed to by @a bytes.
     * 
     * @return the newly allocated buffer state object.
     */
    YY_BUFFER_STATE gmsh_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
    {
    	YY_BUFFER_STATE b;
    	char *buf;
    	yy_size_t n;
    	int i;
        
    	/* Get memory for full buffer, including space for trailing EOB's. */
    	n = _yybytes_len + 2;
    	buf = (char *) gmsh_yyalloc(n  );
    	if ( ! buf )
    		YY_FATAL_ERROR( "out of dynamic memory in gmsh_yy_scan_bytes()" );
    
    	for ( i = 0; i < _yybytes_len; ++i )
    		buf[i] = yybytes[i];
    
    	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    
    	b = gmsh_yy_scan_buffer(buf,n );
    	if ( ! b )
    		YY_FATAL_ERROR( "bad buffer in gmsh_yy_scan_bytes()" );
    
    	/* It's okay to grow etc. this buffer, and we should throw it
    	 * away when we're done.
    	 */
    	b->yy_is_our_buffer = 1;
    
    	return b;
    }
    
    #ifndef YY_EXIT_FAILURE
    #define YY_EXIT_FAILURE 2
    #endif
    
    static void yy_fatal_error (yyconst char* msg )
    {
        	(void) fprintf( stderr, "%s\n", msg );
    	exit( YY_EXIT_FAILURE );
    }
    
    /* Redefine yyless() so it works in section 3 code. */
    
    #undef yyless
    #define yyless(n) \
    	do \
    		{ \
    		/* Undo effects of setting up gmsh_yytext. */ \
            int yyless_macro_arg = (n); \
            YY_LESS_LINENO(yyless_macro_arg);\
    		gmsh_yytext[gmsh_yyleng] = (yy_hold_char); \
    		(yy_c_buf_p) = gmsh_yytext + yyless_macro_arg; \
    		(yy_hold_char) = *(yy_c_buf_p); \
    		*(yy_c_buf_p) = '\0'; \
    		gmsh_yyleng = yyless_macro_arg; \
    		} \
    	while ( 0 )
    
    /* Accessor  methods (get/set functions) to struct members. */
    
    /** Get the current line number.
     * 
     */
    int gmsh_yyget_lineno  (void)
    {
            
        return gmsh_yylineno;
    }
    
    /** Get the input stream.
     * 
     */
    FILE *gmsh_yyget_in  (void)
    {
            return gmsh_yyin;
    }
    
    /** Get the output stream.
     * 
     */
    FILE *gmsh_yyget_out  (void)
    {
            return gmsh_yyout;
    }
    
    /** Get the length of the current token.
     * 
     */
    int gmsh_yyget_leng  (void)
    {
            return gmsh_yyleng;
    }
    
    /** Get the current token.
     * 
     */
    
    char *gmsh_yyget_text  (void)
    {
            return gmsh_yytext;
    }
    
    /** Set the current line number.
     * @param line_number
     * 
     */
    void gmsh_yyset_lineno (int  line_number )
    {
        
        gmsh_yylineno = line_number;
    }
    
    /** Set the input stream. This does not discard the current
     * input buffer.
     * @param in_str A readable stream.
     * 
     * @see gmsh_yy_switch_to_buffer
     */
    void gmsh_yyset_in (FILE *  in_str )
    {
            gmsh_yyin = in_str ;
    }
    
    void gmsh_yyset_out (FILE *  out_str )
    {
            gmsh_yyout = out_str ;
    }
    
    int gmsh_yyget_debug  (void)
    {
            return gmsh_yy_flex_debug;
    }
    
    void gmsh_yyset_debug (int  bdebug )
    {
            gmsh_yy_flex_debug = bdebug ;
    }
    
    static int yy_init_globals (void)
    {
            /* Initialization is the same as for the non-reentrant scanner.
         * This function is called from gmsh_yylex_destroy(), so don't allocate here.
         */
    
        (yy_buffer_stack) = 0;
        (yy_buffer_stack_top) = 0;
        (yy_buffer_stack_max) = 0;
        (yy_c_buf_p) = (char *) 0;
        (yy_init) = 0;
        (yy_start) = 0;
    
    /* Defined in main.c */
    #ifdef YY_STDINIT
        gmsh_yyin = stdin;
        gmsh_yyout = stdout;
    #else
        gmsh_yyin = (FILE *) 0;
        gmsh_yyout = (FILE *) 0;
    #endif
    
        /* For future reference: Set errno on error, since we are called by
         * gmsh_yylex_init()
         */
        return 0;
    }
    
    /* gmsh_yylex_destroy is for both reentrant and non-reentrant scanners. */
    int gmsh_yylex_destroy  (void)
    {
        
        /* Pop the buffer stack, destroying each element. */
    	while(YY_CURRENT_BUFFER){
    		gmsh_yy_delete_buffer(YY_CURRENT_BUFFER  );
    		YY_CURRENT_BUFFER_LVALUE = NULL;
    		gmsh_yypop_buffer_state();
    	}
    
    	/* Destroy the stack itself. */
    	gmsh_yyfree((yy_buffer_stack) );
    	(yy_buffer_stack) = NULL;
    
        /* Reset the globals. This is important in a non-reentrant scanner so the next time
         * gmsh_yylex() is called, initialization will occur. */
        yy_init_globals( );
    
        return 0;
    }
    
    /*
     * Internal utility routines.
     */
    
    #ifndef yytext_ptr
    static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
    {
    	register int i;
    	for ( i = 0; i < n; ++i )
    		s1[i] = s2[i];
    }
    #endif
    
    #ifdef YY_NEED_STRLEN
    static int yy_flex_strlen (yyconst char * s )
    {
    	register int n;
    	for ( n = 0; s[n]; ++n )
    		;
    
    	return n;
    }
    #endif
    
    void *gmsh_yyalloc (yy_size_t  size )
    {
    	return (void *) malloc( size );
    }
    
    void *gmsh_yyrealloc  (void * ptr, yy_size_t  size )
    {
    	/* 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 );
    }
    
    void gmsh_yyfree (void * ptr )
    {
    	free( (char *) ptr );	/* see gmsh_yyrealloc() for (char *) cast */
    }
    
    #define YYTABLES_NAME "yytables"
    
    #line 221 "Gmsh.l"
    
    
    
    #undef gmsh_yywrap
    
    int gmsh_yywrap() {return 1;}
    
    void skipcomments(void)
    {
      int c;
    
      while (1) {
        while ((c = yyinput()) != '*'){
          if(feof(gmsh_yyin)){
    	Msg::Error("End of file in commented region");
            return;
          }
        }
        if ((c = yyinput()) == '/')
          return;
        unput(c);
      }
    }
    
    void parsestring(char endchar)
    {
      int c;
      char tmp[1024];
      
      // Note that we keep special characters (end-of-line \n, tabs \t,
      // etc.) "as is" in the output string: see yyinput() above
      int i = 0;
      while ((c = yyinput()) != endchar) {
        if(feof(gmsh_yyin)){
          Msg::Error("End of file in string");
          break;
        }
        else if(i >= (int)sizeof(tmp)-1){
          Msg::Error("String too long");
          break;
        }
        else{
          tmp[i++] = (char)c;
        }
      }
      tmp[i] = '\0';
      gmsh_yylval.c = strsave(tmp);
    }
    
    char *strsave(char *ptr)
    {
      return((char*)strcpy((char*)malloc(strlen(ptr)+1),ptr));
    }
    
    void skipline()
    {
      int c;
      while ((c = yyinput()) != '\n'){
        if(feof(gmsh_yyin)) return;
      }
    }
    
    void skip_until(const char *skip, const char *until)
    {
      int i, nb_skip;
      int l, l_skip, l_until;
      char chars[256];
    
      nb_skip = 0;
    
      if(skip)
        l_skip = strlen(skip);
      else
        l_skip = 0;
    
      l_until = strlen(until);
    
      while(1){
        while (1){
          chars[0] = yyinput();
          if(feof(gmsh_yyin)){
    	Msg::Error("Unexpected end of file");
    	return;
          }
          if(chars[0] == until[0]) break;
          if(skip && chars[0] == skip[0]) break;
        }
    
        l = std::max(l_skip,l_until);
        if(l >= (int)sizeof(chars)){
          Msg::Error("Search pattern too long in skip_until");
          return;
        }
        for(i=1; i<l; i++){
          chars[i] = yyinput();
          if(feof(gmsh_yyin)){
    	l = i;
    	break;
          }
        }
    
        if(!strncmp(chars,until,l_until)){
          if(!nb_skip){
    	return;
          }
          else{
    	nb_skip--;
          }
        }
        else if(skip && !strncmp(chars,skip,l_skip)){
          nb_skip++;
        }
        else{
          for(i=1;i<l-1;i++){
    	unput(chars[l-i]);
          }
        }
    
      }
    }
    
    void gmsh_yyflush() { YY_FLUSH_BUFFER; }