text: #line 2 "flex-chapel.cpp"
  
  #line 4 "flex-chapel.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 35
  #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 defined (__STDC_VERSION__) && __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;
  typedef uint64_t flex_uint64_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 */
  
  /* C99 requires __STDC__ to be defined as 1. */
  #if defined (__STDC__)
  
  #define YY_USE_CONST
  
  #endif	/* defined (__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)
  
  /* An opaque pointer. */
  #ifndef YY_TYPEDEF_YY_SCANNER_T
  #define YY_TYPEDEF_YY_SCANNER_T
  typedef void* yyscan_t;
  #endif
  
  /* For convenience, these vars (plus the bison vars far below)
     are macros in the reentrant scanner. */
  #define yyin yyg->yyin_r
  #define yyout yyg->yyout_r
  #define yyextra yyg->yyextra_r
  #define yyleng yyg->yyleng_r
  #define yytext yyg->yytext_r
  #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
  #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
  #define yy_flex_debug yyg->yy_flex_debug_r
  
  /* 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 yyg->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 ((yyg->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 yyrestart(yyin ,yyscanner )
  
  #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
  
  #ifndef YY_TYPEDEF_YY_SIZE_T
  #define YY_TYPEDEF_YY_SIZE_T
  typedef size_t yy_size_t;
  #endif
  
  #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 yytext. */ \
          int yyless_macro_arg = (n); \
          YY_LESS_LINENO(yyless_macro_arg);\
  		*yy_cp = yyg->yy_hold_char; \
  		YY_RESTORE_YY_MORE_OFFSET \
  		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
  		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  		} \
  	while ( 0 )
  
  #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
  
  #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.
  	 */
  	yy_size_t 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 yyrestart()), so that the user can continue scanning by
  	 * just pointing yyin at a new input file.
  	 */
  #define YY_BUFFER_EOF_PENDING 2
  
  	};
  #endif /* !YY_STRUCT_YY_BUFFER_STATE */
  
  /* 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 ( yyg->yy_buffer_stack \
                            ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
  
  void yyrestart (FILE *input_file ,yyscan_t yyscanner );
  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
  YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
  void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
  void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
  void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
  void yypop_buffer_state (yyscan_t yyscanner );
  
  static void yyensure_buffer_stack (yyscan_t yyscanner );
  static void yy_load_buffer_state (yyscan_t yyscanner );
  static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
  
  #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
  
  YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
  YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
  YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
  
  void *yyalloc (yy_size_t ,yyscan_t yyscanner );
  void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
  void yyfree (void * ,yyscan_t yyscanner );
  
  #define yy_new_buffer yy_create_buffer
  
  #define yy_set_interactive(is_interactive) \
  	{ \
  	if ( ! YY_CURRENT_BUFFER ){ \
          yyensure_buffer_stack (yyscanner); \
  		YY_CURRENT_BUFFER_LVALUE =    \
              yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
  	} \
  	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  	}
  
  #define yy_set_bol(at_bol) \
  	{ \
  	if ( ! YY_CURRENT_BUFFER ){\
          yyensure_buffer_stack (yyscanner); \
  		YY_CURRENT_BUFFER_LVALUE =    \
              yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
  	} \
  	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  	}
  
  #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
  
  /* Begin user sect3 */
  
  #define yywrap(n) 1
  #define YY_SKIP_YYWRAP
  
  typedef unsigned char YY_CHAR;
  
  typedef int yy_state_type;
  
  #define yytext_ptr yytext_r
  
  static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
  static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
  static int yy_get_next_buffer (yyscan_t yyscanner );
  static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
  
  /* Done after the current pattern has been matched and before the
   * corresponding action - sets up yytext.
   */
  #define YY_DO_BEFORE_ACTION \
  	yyg->yytext_ptr = yy_bp; \
  	yyleng = (yy_size_t) (yy_cp - yy_bp); \
  	yyg->yy_hold_char = *yy_cp; \
  	*yy_cp = '\0'; \
  	yyg->yy_c_buf_p = yy_cp;
  
  #define YY_NUM_RULES 141
  #define YY_END_OF_BUFFER 142
  /* 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[385] =
      {   0,
          0,    0,    0,    0,  142,  140,  139,  138,   93,  132,
         88,  110,   94,  133,  118,  119,  108,  106,  116,  107,
        117,  109,  127,  127,  114,  115,  104,   72,  105,  126,
        131,  120,  121,   96,   71,  131,  131,  131,  131,  131,
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,  131,  131,  131,  131,  123,   95,  124,   97,  122,
        101,   78,   91,   79,  113,   75,  112,   73,  111,   74,
         89,  128,  137,  136,   76,    0,  127,    0,    0,    0,
          0,  129,   98,  102,    0,  100,   86,  103,   99,  131,
         81,  131,  131,    2,  131,  131,  131,    6,  134,  135,
  
        131,  131,  131,  131,   15,  131,  131,  131,  131,   24,
         25,  131,  131,  131,  131,  131,  131,  131,  131,   38,
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,   80,   92,   82,   77,   90,    0,  130,    0,  127,
          0,  128,  127,    0,  127,   84,   87,  125,   85,  131,
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,  131,  131,  131,  131,  131,   22,  131,  131,  131,
        131,  131,  131,   32,  131,  131,   35,   36,  131,  131,
        131,   41,  131,  131,  131,  131,  131,  131,  131,   50,
  
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,  131,   63,   64,  131,  131,  131,  131,   70,   83,
          0,  128,    0,  128,  128,    0,    0,  131,  131,  131,
        131,  131,  131,  131,  131,  131,  131,  131,  131,  131,
        131,   17,   18,  131,  131,  131,  131,  131,  131,  131,
         29,  131,  131,  131,  131,  131,   39,  131,  131,  131,
        131,   46,  131,  131,  131,  131,  131,   53,  131,  131,
        131,  131,  131,   59,   60,   61,  131,   65,  131,  131,
         68,  131,    0,    0,    0,  128,  131,    1,  131,    4,
          5,    7,  131,  131,  131,   11,  131,  131,  131,  131,
  
        131,  131,  131,  131,   26,  131,   28,   30,  131,   33,
        131,  131,  131,   42,  131,  131,  131,  131,  131,  131,
        131,  131,  131,  131,  131,  131,   62,   66,   67,   69,
          0,  128,    0,  128,  131,    3,  131,  131,   10,  131,
         13,  131,   16,   20,   19,   21,   23,   27,   31,   34,
         37,  131,   43,  131,   47,   48,   49,  131,   52,   54,
         55,   56,   57,  131,  131,    8,  131,  131,   14,  131,
         45,   51,  131,  131,    9,   12,  131,  131,  131,   40,
         58,  131,   44,    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,    6,    7,    8,    9,   10,   11,
         12,   13,   14,   15,   16,   17,   18,   19,   20,   21,
         21,   21,   21,   21,   21,   22,   22,   23,   24,   25,
         26,   27,   28,    1,   29,   30,   29,   29,   31,   29,
         32,   32,   32,   32,   32,   32,   32,   32,   33,   34,
         32,   32,   32,   32,   32,   32,   32,   35,   32,   32,
         36,    1,   37,   38,   39,    1,   40,   41,   42,   43,
  
         44,   45,   46,   47,   48,   32,   49,   50,   51,   52,
         53,   54,   55,   56,   57,   58,   59,   60,   61,   62,
         63,   64,   65,   66,   67,   68,    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[69] =
      {   0,
          1,    1,    1,    1,    1,    1,    2,    1,    1,    1,
          1,    1,    1,    1,    1,    1,    3,    1,    4,    4,
          4,    4,    1,    1,    1,    1,    1,    1,    4,    4,
          4,    2,    2,    2,    2,    1,    1,    1,    2,    4,
          4,    4,    4,    4,    4,    2,    2,    2,    2,    2,
          2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
          2,    2,    2,    2,    1,    1,    1,    1
      } ;
  
  static yyconst flex_int16_t yy_base[388] =
      {   0,
          0,    0,  460,  459,  523,  526,  526,  526,  496,  526,
        526,  495,   60,  526,  526,  526,   57,   58,  526,   55,
         56,   61,   71,   77,  526,  526,   84,   87,   90,  526,
          0,  526,  526,  494,  480,   70,   67,   90,   78,   82,
        465,   90,   97,  464,  101,   99,  106,  472,  119,   42,
         28,  475,   91,  466,  465,  526,   81,  526,  526,  526,
        526,  526,  486,  526,  485,  526,  526,  526,  526,  526,
        493,  149,  526,  526,  526,  155,  170,  136,  184,  164,
        492,  526,  482,  480,  479,  526,  526,  526,  479,    0,
        526,  450,  455,    0,  449,  455,  456,    0,  526,  526,
  
        459,  167,  448,  457,  445,  438,  435,  153,  437,    0,
        167,  448,   85,  433,  448,  446,  427,  437,  438,  435,
        437,  425,  426,  173,  440,  180,  440,  103,  427,  438,
        436,  424,  431,  420,  425,  428,  415,  116,  412,  425,
        414,  526,  441,  526,  526,  526,  220,  526,  229,  196,
        208,  233,  212,    0,  229,  526,  526,  526,  526,  410,
        419,  413,  415,  422,  404,  416,  406,  211,  414,  403,
        416,  411,  403,  409,  399,  407,  410,  405,  400,  388,
        390,  401,  403,    0,  403,  383,    0,    0,  389,  377,
        395,    0,  398,  391,  376,  393,  384,  380,  373,    0,
  
        372,  371,  377,  384,  379,  380,  369,  381,  381,  370,
        377,  367,    0,    0,  205,  369,  371,  367,    0,  526,
        245,  251,  265,  269,  228,  224,  281,  368,  363,  366,
        361,  363,  354,  364,  353,  360,  349,  358,  347,  350,
        355,    0,    0,  348,  345,  344,  349,  336,  345,  338,
          0,  345,  351,  343,  342,  343,    0,  334,  338,  337,
        347,    0,  338,  329,  342,  335,  326,    0,  339,  340,
        329,  321,  324,    0,    0,    0,  321,    0,  326,  325,
          0,  325,  290,  299,  303,  307,  316,    0,  324,    0,
          0,    0,  317,  324,  316,    0,  309,  316,  315,  306,
  
        299,  298,  302,  303,    0,  308,    0,    0,  311,    0,
        306,  291,  287,    0,  307,  288,  274,  271,  264,  251,
        253,  240,  246,  250,  249,  241,    0,    0,    0,    0,
        311,  315,  319,  323,  232,    0,  227,  225,    0,  215,
          0,  216,    0,    0,    0,    0,    0,    0,    0,    0,
          0,  199,    0,  193,    0,    0,    0,  180,    0,    0,
          0,    0,    0,  169,  144,    0,  146,  150,    0,  131,
          0,    0,  133,  131,    0,    0,  128,  114,   58,    0,
          0,   59,    0,  526,  370,  372,   78
      } ;
  
  static yyconst flex_int16_t yy_def[388] =
      {   0,
        384,    1,    1,    1,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        385,  384,  384,  384,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        386,  384,  384,  384,  384,  384,  384,  384,  384,  385,
        384,  385,  385,  385,  385,  385,  385,  385,  384,  384,
  
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  387,  386,  384,  384,  384,  384,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
  
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  384,
        384,  384,  384,  384,  387,  387,  384,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  384,  384,  384,  384,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
  
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        384,  384,  384,  384,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
        385,  385,  385,    0,  384,  384,  384
      } ;
  
  static yyconst flex_int16_t yy_nxt[595] =
      {   0,
          6,    7,    8,    9,   10,   11,    6,   12,   13,   14,
         15,   16,   17,   18,   19,   20,   21,   22,   23,   24,
         24,   24,   25,   26,   27,   28,   29,   30,   31,   31,
         31,   31,   31,   31,   31,   32,   33,   34,   35,   36,
         37,   38,   39,   40,   41,   31,   31,   42,   31,   43,
         44,   45,   46,   47,   31,   48,   49,   50,   51,   52,
         53,   31,   54,   55,   56,   57,   58,   59,   63,   65,
         69,   67,   71,   73,   72,   72,   72,   72,   74,  135,
         70,  225,   66,   68,  136,   64,   75,   76,  133,   77,
         77,   77,   77,   76,   99,   77,   77,   77,   77,  100,
  
         78,   79,  383,   80,  134,   81,  142,   79,   83,   84,
         96,   78,   86,   87,   79,   88,   89,  382,   82,   93,
         79,  103,   97,   80,   82,  182,   94,   95,  104,   98,
        105,  106,   81,  107,  110,  183,  113,  138,  139,  101,
        114,  111,  102,  108,  117,  123,  143,  112,  118,  115,
        120,   85,  204,  119,  150,  150,  121,  122,  205,  215,
        127,  124,  128,  216,  125,  381,  129,   72,   72,   72,
         72,  380,  130,   72,   72,   72,   72,  131,  379,  147,
        378,  132,  153,  153,  153,  149,   76,  377,   77,   77,
         77,   77,  147,  376,  174,  375,  148,  151,  149,  151,
  
         79,  374,  152,  152,  152,  152,  175,  166,  373,  178,
        176,  167,  194,   79,  150,  150,  179,   82,  168,  180,
        195,  198,  199,  372,  200,  196,  152,  152,  152,  152,
        153,  153,  153,  221,  201,  221,  371,  202,  222,  222,
        222,  222,  223,   82,  223,  226,  370,  224,  224,  224,
        224,  152,  152,  152,  152,  236,  278,  284,  369,   82,
        279,  283,  227,  222,  222,  222,  222,  237,  238,  222,
        222,  222,  222,  368,  367,  148,   82,  284,  366,  365,
        148,  283,  227,  224,  224,  224,  224,  224,  224,  224,
        224,  364,  363,  362,  285,  361,  285,  360,  148,  286,
  
        286,  286,  286,  331,  359,  331,  358,  357,  332,  332,
        332,  332,  333,  356,  333,  355,  148,  334,  334,  334,
        334,  286,  286,  286,  286,  286,  286,  286,  286,  332,
        332,  332,  332,  332,  332,  332,  332,  334,  334,  334,
        334,  334,  334,  334,  334,  354,  353,  352,  351,  350,
        349,  348,  347,  346,  148,  345,  344,  343,  342,  341,
        340,  339,  148,  338,  337,  336,  335,  330,  329,  328,
        148,   90,  327,   90,  155,  155,  326,  325,  324,  323,
        322,  321,  320,  319,  318,  317,  316,  315,  314,  313,
        312,  311,  310,  309,  308,  307,  306,  305,  304,  303,
  
        302,  301,  300,  299,  298,  297,  296,  295,  294,  293,
        292,  291,  290,  289,  288,  287,  282,  281,  280,  277,
        276,  275,  274,  273,  272,  271,  270,  269,  268,  267,
        266,  265,  264,  263,  262,  261,  260,  259,  258,  257,
        256,  255,  254,  253,  252,  251,  250,  249,  248,  247,
        246,  245,  244,  243,  242,  241,  240,  239,  235,  234,
        233,  232,  231,  230,  229,  228,  220,  219,  218,  217,
        214,  213,  212,  211,  210,  209,  208,  207,  206,  203,
        197,  193,  192,  191,  190,  189,  188,  187,  186,  185,
        184,  181,  177,  173,  172,  171,  170,  169,  165,  164,
  
        163,  162,  161,  160,  159,  158,  157,  156,  154,  146,
        145,  144,  141,  140,  137,  126,  116,  109,   92,   91,
         62,   61,  384,   60,   60,    5,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384
  
      } ;
  
  static yyconst flex_int16_t yy_chk[595] =
      {   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,   13,   17,
         20,   18,   21,   22,   21,   21,   21,   21,   22,   51,
         20,  387,   17,   18,   51,   13,   22,   23,   50,   23,
         23,   23,   23,   24,   38,   24,   24,   24,   24,   38,
  
         23,   23,  382,   23,   50,   23,   57,   24,   27,   27,
         37,   23,   28,   28,   23,   29,   29,  379,   23,   36,
         24,   39,   37,   23,   24,  113,   36,   36,   39,   37,
         39,   40,   23,   40,   42,  113,   43,   53,   53,   38,
         43,   42,   38,   40,   45,   47,   57,   42,   45,   43,
         46,   27,  128,   45,   78,   78,   46,   46,  128,  138,
         49,   47,   49,  138,   47,  378,   49,   72,   72,   72,
         72,  377,   49,   76,   76,   76,   76,   49,  374,   72,
        373,   49,   80,   80,   80,   76,   77,  370,   77,   77,
         77,   77,   72,  368,  108,  367,   72,   79,   76,   79,
  
         77,  365,   79,   79,   79,   79,  108,  102,  364,  111,
        108,  102,  124,   77,  150,  150,  111,   77,  102,  111,
        124,  126,  126,  358,  126,  124,  151,  151,  151,  151,
        153,  153,  153,  147,  126,  147,  354,  126,  147,  147,
        147,  147,  149,  150,  149,  155,  352,  149,  149,  149,
        149,  152,  152,  152,  152,  168,  215,  226,  342,  153,
        215,  225,  155,  221,  221,  221,  221,  168,  168,  222,
        222,  222,  222,  340,  338,  225,  155,  226,  337,  335,
        152,  225,  155,  223,  223,  223,  223,  224,  224,  224,
        224,  326,  325,  324,  227,  323,  227,  322,  222,  227,
  
        227,  227,  227,  283,  321,  283,  320,  319,  283,  283,
        283,  283,  284,  318,  284,  317,  224,  284,  284,  284,
        284,  285,  285,  285,  285,  286,  286,  286,  286,  331,
        331,  331,  331,  332,  332,  332,  332,  333,  333,  333,
        333,  334,  334,  334,  334,  316,  315,  313,  312,  311,
        309,  306,  304,  303,  286,  302,  301,  300,  299,  298,
        297,  295,  332,  294,  293,  289,  287,  282,  280,  279,
        334,  385,  277,  385,  386,  386,  273,  272,  271,  270,
        269,  267,  266,  265,  264,  263,  261,  260,  259,  258,
        256,  255,  254,  253,  252,  250,  249,  248,  247,  246,
  
        245,  244,  241,  240,  239,  238,  237,  236,  235,  234,
        233,  232,  231,  230,  229,  228,  218,  217,  216,  212,
        211,  210,  209,  208,  207,  206,  205,  204,  203,  202,
        201,  199,  198,  197,  196,  195,  194,  193,  191,  190,
        189,  186,  185,  183,  182,  181,  180,  179,  178,  177,
        176,  175,  174,  173,  172,  171,  170,  169,  167,  166,
        165,  164,  163,  162,  161,  160,  143,  141,  140,  139,
        137,  136,  135,  134,  133,  132,  131,  130,  129,  127,
        125,  123,  122,  121,  120,  119,  118,  117,  116,  115,
        114,  112,  109,  107,  106,  105,  104,  103,  101,   97,
  
         96,   95,   93,   92,   89,   85,   84,   83,   81,   71,
         65,   63,   55,   54,   52,   48,   44,   41,   35,   34,
         12,    9,    5,    4,    3,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384,  384,  384,  384,  384,  384,  384,
        384,  384,  384,  384
  
      } ;
  
  /* 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
  #line 1 "chapel.lex"
  /*
   * Copyright 2004-2016 Cray Inc.
   * Other additional copyright holders may be indicated within.
   *
   * The entirety of this work is licensed under the Apache License,
   * Version 2.0 (the "License"); you may not use this file except
   * in compliance with the License.
   *
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /* These options create a re-entrant scanner that returns
       an integer to indicate the token type
       a  bison-style YYSTYPE by reference. The value will always be in yylval->pch.
       a  bison-style YYLTYPE by reference.
  
       i.e. int yylex(YYSTYPE*,YYLTYPE*,yyscan_t yyscanner);
  */
  /*
     Provide a condition stack
     This is used to alter the handling of "{" when it appears immediately after "extern"
  */
  #line 46 "chapel.lex"
  
  #include "bison-chapel.h"
  #include "docsDriver.h"
  #include "parser.h"
  
  #include <cstdio>
  
  //
  // Make sure exit is undefined:
  //
  
  #ifdef exit
  #undef exit
  #endif
  
  // And redefine it to call our exit routine:
  #define exit(x) clean_exit(x)
  
  static int  processIdentifier(yyscan_t scanner);
  static int  processToken(yyscan_t scanner, int t);
  static int  processStringLiteral(yyscan_t scanner, const char* q, int type);
  
  static int  processExtern(yyscan_t scanner);
  static int  processExternCode(yyscan_t scanner);
  
  static void processWhitespace(yyscan_t scanner);
  
  static int  processSingleLineComment(yyscan_t scanner);
  static int  processBlockComment(yyscan_t scanner);
  
  static void processInvalidToken(yyscan_t scanner);
  
  static bool yy_has_state(yyscan_t scanner);
  
  /* hex float literals, have decimal exponents indicating the power of 2 */
  
  #line 758 "flex-chapel.cpp"
  
  #define INITIAL 0
  #define externmode 1
  
  #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
  
  /* Holds the entire state of the reentrant scanner. */
  struct yyguts_t
      {
  
      /* User-defined. Not touched by flex. */
      YY_EXTRA_TYPE yyextra_r;
  
      /* The rest are the same as the globals declared in the non-reentrant scanner. */
      FILE *yyin_r, *yyout_r;
      size_t yy_buffer_stack_top; /**< index of top of stack. */
      size_t yy_buffer_stack_max; /**< capacity of stack. */
      YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
      char yy_hold_char;
      yy_size_t yy_n_chars;
      yy_size_t yyleng_r;
      char *yy_c_buf_p;
      int yy_init;
      int yy_start;
      int yy_did_buffer_switch_on_eof;
      int yy_start_stack_ptr;
      int yy_start_stack_depth;
      int *yy_start_stack;
      yy_state_type yy_last_accepting_state;
      char* yy_last_accepting_cpos;
  
      int yylineno_r;
      int yy_flex_debug_r;
  
      char *yytext_r;
      int yy_more_flag;
      int yy_more_len;
  
      YYSTYPE * yylval_r;
  
      YYLTYPE * yylloc_r;
  
      }; /* end struct yyguts_t */
  
  static int yy_init_globals (yyscan_t yyscanner );
  
      /* This must go here because YYSTYPE and YYLTYPE are included
       * from bison output in section 1.*/
      #    define yylval yyg->yylval_r
      
      #    define yylloc yyg->yylloc_r
      
  int yylex_init (yyscan_t* scanner);
  
  int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
  
  /* Accessor methods to globals.
     These are made visible to non-reentrant scanners for convenience. */
  
  int yylex_destroy (yyscan_t yyscanner );
  
  int yyget_debug (yyscan_t yyscanner );
  
  void yyset_debug (int debug_flag ,yyscan_t yyscanner );
  
  YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
  
  void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
  
  FILE *yyget_in (yyscan_t yyscanner );
  
  void yyset_in  (FILE * in_str ,yyscan_t yyscanner );
  
  FILE *yyget_out (yyscan_t yyscanner );
  
  void yyset_out  (FILE * out_str ,yyscan_t yyscanner );
  
  yy_size_t yyget_leng (yyscan_t yyscanner );
  
  char *yyget_text (yyscan_t yyscanner );
  
  int yyget_lineno (yyscan_t yyscanner );
  
  void yyset_lineno (int line_number ,yyscan_t yyscanner );
  
  YYSTYPE * yyget_lval (yyscan_t yyscanner );
  
  void yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
  
         YYLTYPE *yyget_lloc (yyscan_t yyscanner );
      
          void yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
      
  /* Macros after this point can all be overridden by user definitions in
   * section 1.
   */
  
  #ifndef YY_SKIP_YYWRAP
  #ifdef __cplusplus
  extern "C" int yywrap (yyscan_t yyscanner );
  #else
  extern int yywrap (yyscan_t yyscanner );
  #endif
  #endif
  
  #ifndef yytext_ptr
  static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
  #endif
  
  #ifdef YY_NEED_STRLEN
  static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
  #endif
  
  #ifndef YY_NO_INPUT
  
  #ifdef __cplusplus
  static int yyinput (yyscan_t yyscanner );
  #else
  static int input (yyscan_t yyscanner );
  #endif
  
  #endif
  
      static void yy_push_state (int new_state ,yyscan_t yyscanner);
      
      static void yy_pop_state (yyscan_t yyscanner );
      
      static int yy_top_state (yyscan_t yyscanner );
      
  /* 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 fwrite( yytext, yyleng, 1, 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 = '*'; \
  		yy_size_t n; \
  		for ( n = 0; n < max_size && \
  			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  			buf[n] = (char) c; \
  		if ( c == '\n' ) \
  			buf[n++] = (char) c; \
  		if ( c == EOF && ferror( yyin ) ) \
  			YY_FATAL_ERROR( "input in flex scanner failed" ); \
  		result = n; \
  		} \
  	else \
  		{ \
  		errno=0; \
  		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
  			{ \
  			if( errno != EINTR) \
  				{ \
  				YY_FATAL_ERROR( "input in flex scanner failed" ); \
  				break; \
  				} \
  			errno=0; \
  			clearerr(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 , yyscanner)
  #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 yylex \
                 (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
  
  #define YY_DECL int yylex \
                 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
  #endif /* !YY_DECL */
  
  /* Code executed at the beginning of each rule, after yytext and 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;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  #line 114 "chapel.lex"
  
  
  #line 1007 "flex-chapel.cpp"
  
      yylval = yylval_param;
  
      yylloc = yylloc_param;
  
  	if ( !yyg->yy_init )
  		{
  		yyg->yy_init = 1;
  
  #ifdef YY_USER_INIT
  		YY_USER_INIT;
  #endif
  
  		if ( ! yyg->yy_start )
  			yyg->yy_start = 1;	/* first start state */
  
  		if ( ! yyin )
  			yyin = stdin;
  
  		if ( ! yyout )
  			yyout = stdout;
  
  		if ( ! YY_CURRENT_BUFFER ) {
  			yyensure_buffer_stack (yyscanner);
  			YY_CURRENT_BUFFER_LVALUE =
  				yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
  		}
  
  		yy_load_buffer_state(yyscanner );
  		}
  
  	while ( 1 )		/* loops until end-of-file is reached */
  		{
  		yy_cp = yyg->yy_c_buf_p;
  
  		/* Support of yytext. */
  		*yy_cp = yyg->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 = yyg->yy_start;
  yy_match:
  		do
  			{
  			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  			if ( yy_accept[yy_current_state] )
  				{
  				yyg->yy_last_accepting_state = yy_current_state;
  				yyg->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 >= 385 )
  					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] != 526 );
  
  yy_find_action:
  		yy_act = yy_accept[yy_current_state];
  		if ( yy_act == 0 )
  			{ /* have to back up */
  			yy_cp = yyg->yy_last_accepting_cpos;
  			yy_current_state = yyg->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 = yyg->yy_hold_char;
  			yy_cp = yyg->yy_last_accepting_cpos;
  			yy_current_state = yyg->yy_last_accepting_state;
  			goto yy_find_action;
  
  case 1:
  YY_RULE_SETUP
  #line 116 "chapel.lex"
  return processToken(yyscanner, TALIGN);
  	YY_BREAK
  case 2:
  YY_RULE_SETUP
  #line 117 "chapel.lex"
  return processToken(yyscanner, TAS);
  	YY_BREAK
  case 3:
  YY_RULE_SETUP
  #line 118 "chapel.lex"
  return processToken(yyscanner, TATOMIC);
  	YY_BREAK
  case 4:
  YY_RULE_SETUP
  #line 119 "chapel.lex"
  return processToken(yyscanner, TBEGIN);
  	YY_BREAK
  case 5:
  YY_RULE_SETUP
  #line 120 "chapel.lex"
  return processToken(yyscanner, TBREAK);
  	YY_BREAK
  case 6:
  YY_RULE_SETUP
  #line 121 "chapel.lex"
  return processToken(yyscanner, TBY);
  	YY_BREAK
  case 7:
  YY_RULE_SETUP
  #line 122 "chapel.lex"
  return processToken(yyscanner, TCLASS);
  	YY_BREAK
  case 8:
  YY_RULE_SETUP
  #line 123 "chapel.lex"
  return processToken(yyscanner, TCOBEGIN);
  	YY_BREAK
  case 9:
  YY_RULE_SETUP
  #line 124 "chapel.lex"
  return processToken(yyscanner, TCOFORALL);
  	YY_BREAK
  case 10:
  YY_RULE_SETUP
  #line 125 "chapel.lex"
  return processToken(yyscanner, TCONFIG);
  	YY_BREAK
  case 11:
  YY_RULE_SETUP
  #line 126 "chapel.lex"
  return processToken(yyscanner, TCONST);
  	YY_BREAK
  case 12:
  YY_RULE_SETUP
  #line 127 "chapel.lex"
  return processToken(yyscanner, TCONTINUE);
  	YY_BREAK
  case 13:
  YY_RULE_SETUP
  #line 128 "chapel.lex"
  return processToken(yyscanner, TDELETE);
  	YY_BREAK
  case 14:
  YY_RULE_SETUP
  #line 129 "chapel.lex"
  return processToken(yyscanner, TDMAPPED);
  	YY_BREAK
  case 15:
  YY_RULE_SETUP
  #line 130 "chapel.lex"
  return processToken(yyscanner, TDO);
  	YY_BREAK
  case 16:
  YY_RULE_SETUP
  #line 131 "chapel.lex"
  return processToken(yyscanner, TDOMAIN);
  	YY_BREAK
  case 17:
  YY_RULE_SETUP
  #line 132 "chapel.lex"
  return processToken(yyscanner, TELSE);
  	YY_BREAK
  case 18:
  YY_RULE_SETUP
  #line 133 "chapel.lex"
  return processToken(yyscanner, TENUM);
  	YY_BREAK
  case 19:
  YY_RULE_SETUP
  #line 134 "chapel.lex"
  return processToken(yyscanner, TEXPORT);
  	YY_BREAK
  case 20:
  YY_RULE_SETUP
  #line 135 "chapel.lex"
  return processToken(yyscanner, TEXCEPT);
  	YY_BREAK
  case 21:
  YY_RULE_SETUP
  #line 136 "chapel.lex"
  return processExtern(yyscanner);
  	YY_BREAK
  case 22:
  YY_RULE_SETUP
  #line 137 "chapel.lex"
  return processToken(yyscanner, TFOR);
  	YY_BREAK
  case 23:
  YY_RULE_SETUP
  #line 138 "chapel.lex"
  return processToken(yyscanner, TFORALL);
  	YY_BREAK
  case 24:
  YY_RULE_SETUP
  #line 139 "chapel.lex"
  return processToken(yyscanner, TIF);
  	YY_BREAK
  case 25:
  YY_RULE_SETUP
  #line 140 "chapel.lex"
  return processToken(yyscanner, TIN);
  	YY_BREAK
  case 26:
  YY_RULE_SETUP
  #line 141 "chapel.lex"
  return processToken(yyscanner, TINDEX);
  	YY_BREAK
  case 27:
  YY_RULE_SETUP
  #line 142 "chapel.lex"
  return processToken(yyscanner, TINLINE);
  	YY_BREAK
  case 28:
  YY_RULE_SETUP
  #line 143 "chapel.lex"
  return processToken(yyscanner, TINOUT);
  	YY_BREAK
  case 29:
  YY_RULE_SETUP
  #line 144 "chapel.lex"
  return processToken(yyscanner, TITER);
  	YY_BREAK
  case 30:
  YY_RULE_SETUP
  #line 145 "chapel.lex"
  return processToken(yyscanner, TLABEL);
  	YY_BREAK
  case 31:
  YY_RULE_SETUP
  #line 146 "chapel.lex"
  return processToken(yyscanner, TLAMBDA);
  	YY_BREAK
  case 32:
  YY_RULE_SETUP
  #line 147 "chapel.lex"
  return processToken(yyscanner, TLET);
  	YY_BREAK
  case 33:
  YY_RULE_SETUP
  #line 148 "chapel.lex"
  return processToken(yyscanner, TLOCAL);
  	YY_BREAK
  case 34:
  YY_RULE_SETUP
  #line 149 "chapel.lex"
  return processToken(yyscanner, TMODULE);
  	YY_BREAK
  case 35:
  YY_RULE_SETUP
  #line 150 "chapel.lex"
  return processToken(yyscanner, TNEW);
  	YY_BREAK
  case 36:
  YY_RULE_SETUP
  #line 151 "chapel.lex"
  return processToken(yyscanner, TNIL);
  	YY_BREAK
  case 37:
  YY_RULE_SETUP
  #line 152 "chapel.lex"
  return processToken(yyscanner, TNOINIT);
  	YY_BREAK
  case 38:
  YY_RULE_SETUP
  #line 153 "chapel.lex"
  return processToken(yyscanner, TON);
  	YY_BREAK
  case 39:
  YY_RULE_SETUP
  #line 154 "chapel.lex"
  return processToken(yyscanner, TONLY);
  	YY_BREAK
  case 40:
  YY_RULE_SETUP
  #line 155 "chapel.lex"
  return processToken(yyscanner, TOTHERWISE);
  	YY_BREAK
  case 41:
  YY_RULE_SETUP
  #line 156 "chapel.lex"
  return processToken(yyscanner, TOUT);
  	YY_BREAK
  case 42:
  YY_RULE_SETUP
  #line 157 "chapel.lex"
  return processToken(yyscanner, TPARAM);
  	YY_BREAK
  case 43:
  YY_RULE_SETUP
  #line 158 "chapel.lex"
  return processToken(yyscanner, TPRAGMA);
  	YY_BREAK
  case 44:
  YY_RULE_SETUP
  #line 159 "chapel.lex"
  return processToken(yyscanner, TPRIMITIVE);
  	YY_BREAK
  case 45:
  YY_RULE_SETUP
  #line 160 "chapel.lex"
  return processToken(yyscanner, TPRIVATE);
  	YY_BREAK
  case 46:
  YY_RULE_SETUP
  #line 161 "chapel.lex"
  return processToken(yyscanner, TPROC);
  	YY_BREAK
  case 47:
  YY_RULE_SETUP
  #line 162 "chapel.lex"
  return processToken(yyscanner, TPUBLIC);
  	YY_BREAK
  case 48:
  YY_RULE_SETUP
  #line 163 "chapel.lex"
  return processToken(yyscanner, TRECORD);
  	YY_BREAK
  case 49:
  YY_RULE_SETUP
  #line 164 "chapel.lex"
  return processToken(yyscanner, TREDUCE);
  	YY_BREAK
  case 50:
  YY_RULE_SETUP
  #line 165 "chapel.lex"
  return processToken(yyscanner, TREF);
  	YY_BREAK
  case 51:
  YY_RULE_SETUP
  #line 166 "chapel.lex"
  return processToken(yyscanner, TREQUIRE);
  	YY_BREAK
  case 52:
  YY_RULE_SETUP
  #line 167 "chapel.lex"
  return processToken(yyscanner, TRETURN);
  	YY_BREAK
  case 53:
  YY_RULE_SETUP
  #line 168 "chapel.lex"
  return processToken(yyscanner, TSCAN);
  	YY_BREAK
  case 54:
  YY_RULE_SETUP
  #line 169 "chapel.lex"
  return processToken(yyscanner, TSELECT);
  	YY_BREAK
  case 55:
  YY_RULE_SETUP
  #line 170 "chapel.lex"
  return processToken(yyscanner, TSERIAL);
  	YY_BREAK
  case 56:
  YY_RULE_SETUP
  #line 171 "chapel.lex"
  return processToken(yyscanner, TSINGLE);
  	YY_BREAK
  case 57:
  YY_RULE_SETUP
  #line 172 "chapel.lex"
  return processToken(yyscanner, TSPARSE);
  	YY_BREAK
  case 58:
  YY_RULE_SETUP
  #line 173 "chapel.lex"
  return processToken(yyscanner, TSUBDOMAIN);
  	YY_BREAK
  case 59:
  YY_RULE_SETUP
  #line 174 "chapel.lex"
  return processToken(yyscanner, TSYNC);
  	YY_BREAK
  case 60:
  YY_RULE_SETUP
  #line 175 "chapel.lex"
  return processToken(yyscanner, TTHEN);
  	YY_BREAK
  case 61:
  YY_RULE_SETUP
  #line 176 "chapel.lex"
  return processToken(yyscanner, TTYPE);
  	YY_BREAK
  case 62:
  YY_RULE_SETUP
  #line 177 "chapel.lex"
  return processToken(yyscanner, TUNION);
  	YY_BREAK
  case 63:
  YY_RULE_SETUP
  #line 178 "chapel.lex"
  return processToken(yyscanner, TUSE);
  	YY_BREAK
  case 64:
  YY_RULE_SETUP
  #line 179 "chapel.lex"
  return processToken(yyscanner, TVAR);
  	YY_BREAK
  case 65:
  YY_RULE_SETUP
  #line 180 "chapel.lex"
  return processToken(yyscanner, TWHEN);
  	YY_BREAK
  case 66:
  YY_RULE_SETUP
  #line 181 "chapel.lex"
  return processToken(yyscanner, TWHERE);
  	YY_BREAK
  case 67:
  YY_RULE_SETUP
  #line 182 "chapel.lex"
  return processToken(yyscanner, TWHILE);
  	YY_BREAK
  case 68:
  YY_RULE_SETUP
  #line 183 "chapel.lex"
  return processToken(yyscanner, TWITH);
  	YY_BREAK
  case 69:
  YY_RULE_SETUP
  #line 184 "chapel.lex"
  return processToken(yyscanner, TYIELD);
  	YY_BREAK
  case 70:
  YY_RULE_SETUP
  #line 185 "chapel.lex"
  return processToken(yyscanner, TZIP);
  	YY_BREAK
  case 71:
  YY_RULE_SETUP
  #line 187 "chapel.lex"
  return processToken(yyscanner, TUNDERSCORE);
  	YY_BREAK
  case 72:
  YY_RULE_SETUP
  #line 189 "chapel.lex"
  return processToken(yyscanner, TASSIGN);
  	YY_BREAK
  case 73:
  YY_RULE_SETUP
  #line 190 "chapel.lex"
  return processToken(yyscanner, TASSIGNPLUS);
  	YY_BREAK
  case 74:
  YY_RULE_SETUP
  #line 191 "chapel.lex"
  return processToken(yyscanner, TASSIGNMINUS);
  	YY_BREAK
  case 75:
  YY_RULE_SETUP
  #line 192 "chapel.lex"
  return processToken(yyscanner, TASSIGNMULTIPLY);
  	YY_BREAK
  case 76:
  YY_RULE_SETUP
  #line 193 "chapel.lex"
  return processToken(yyscanner, TASSIGNDIVIDE);
  	YY_BREAK
  case 77:
  YY_RULE_SETUP
  #line 194 "chapel.lex"
  return processToken(yyscanner, TASSIGNEXP);
  	YY_BREAK
  case 78:
  YY_RULE_SETUP
  #line 195 "chapel.lex"
  return processToken(yyscanner, TASSIGNMOD);
  	YY_BREAK
  case 79:
  YY_RULE_SETUP
  #line 196 "chapel.lex"
  return processToken(yyscanner, TASSIGNBAND);
  	YY_BREAK
  case 80:
  YY_RULE_SETUP
  #line 197 "chapel.lex"
  return processToken(yyscanner, TASSIGNBOR);
  	YY_BREAK
  case 81:
  YY_RULE_SETUP
  #line 198 "chapel.lex"
  return processToken(yyscanner, TASSIGNBXOR);
  	YY_BREAK
  case 82:
  YY_RULE_SETUP
  #line 199 "chapel.lex"
  return processToken(yyscanner, TASSIGNLAND);
  	YY_BREAK
  case 83:
  YY_RULE_SETUP
  #line 200 "chapel.lex"
  return processToken(yyscanner, TASSIGNLOR);
  	YY_BREAK
  case 84:
  YY_RULE_SETUP
  #line 201 "chapel.lex"
  return processToken(yyscanner, TASSIGNSL);
  	YY_BREAK
  case 85:
  YY_RULE_SETUP
  #line 202 "chapel.lex"
  return processToken(yyscanner, TASSIGNSR);
  	YY_BREAK
  case 86:
  YY_RULE_SETUP
  #line 204 "chapel.lex"
  return processToken(yyscanner, TALIAS);
  	YY_BREAK
  case 87:
  YY_RULE_SETUP
  #line 206 "chapel.lex"
  return processToken(yyscanner, TSWAP);
  	YY_BREAK
  case 88:
  YY_RULE_SETUP
  #line 208 "chapel.lex"
  return processToken(yyscanner, THASH);
  	YY_BREAK
  case 89:
  YY_RULE_SETUP
  #line 209 "chapel.lex"
  return processToken(yyscanner, TDOTDOT);
  	YY_BREAK
  case 90:
  YY_RULE_SETUP
  #line 210 "chapel.lex"
  return processToken(yyscanner, TDOTDOTDOT);
  	YY_BREAK
  case 91:
  YY_RULE_SETUP
  #line 212 "chapel.lex"
  return processToken(yyscanner, TAND);
  	YY_BREAK
  case 92:
  YY_RULE_SETUP
  #line 213 "chapel.lex"
  return processToken(yyscanner, TOR);
  	YY_BREAK
  case 93:
  YY_RULE_SETUP
  #line 214 "chapel.lex"
  return processToken(yyscanner, TNOT);
  	YY_BREAK
  case 94:
  YY_RULE_SETUP
  #line 216 "chapel.lex"
  return processToken(yyscanner, TBAND);
  	YY_BREAK
  case 95:
  YY_RULE_SETUP
  #line 217 "chapel.lex"
  return processToken(yyscanner, TBOR);
  	YY_BREAK
  case 96:
  YY_RULE_SETUP
  #line 218 "chapel.lex"
  return processToken(yyscanner, TBXOR);
  	YY_BREAK
  case 97:
  YY_RULE_SETUP
  #line 219 "chapel.lex"
  return processToken(yyscanner, TBNOT);
  	YY_BREAK
  case 98:
  YY_RULE_SETUP
  #line 221 "chapel.lex"
  return processToken(yyscanner, TSHIFTLEFT);
  	YY_BREAK
  case 99:
  YY_RULE_SETUP
  #line 222 "chapel.lex"
  return processToken(yyscanner, TSHIFTRIGHT);
  	YY_BREAK
  case 100:
  YY_RULE_SETUP
  #line 224 "chapel.lex"
  return processToken(yyscanner, TEQUAL);
  	YY_BREAK
  case 101:
  YY_RULE_SETUP
  #line 225 "chapel.lex"
  return processToken(yyscanner, TNOTEQUAL);
  	YY_BREAK
  case 102:
  YY_RULE_SETUP
  #line 226 "chapel.lex"
  return processToken(yyscanner, TLESSEQUAL);
  	YY_BREAK
  case 103:
  YY_RULE_SETUP
  #line 227 "chapel.lex"
  return processToken(yyscanner, TGREATEREQUAL);
  	YY_BREAK
  case 104:
  YY_RULE_SETUP
  #line 228 "chapel.lex"
  return processToken(yyscanner, TLESS);
  	YY_BREAK
  case 105:
  YY_RULE_SETUP
  #line 229 "chapel.lex"
  return processToken(yyscanner, TGREATER);
  	YY_BREAK
  case 106:
  YY_RULE_SETUP
  #line 231 "chapel.lex"
  return processToken(yyscanner, TPLUS);
  	YY_BREAK
  case 107:
  YY_RULE_SETUP
  #line 232 "chapel.lex"
  return processToken(yyscanner, TMINUS);
  	YY_BREAK
  case 108:
  YY_RULE_SETUP
  #line 233 "chapel.lex"
  return processToken(yyscanner, TSTAR);
  	YY_BREAK
  case 109:
  YY_RULE_SETUP
  #line 234 "chapel.lex"
  return processToken(yyscanner, TDIVIDE);
  	YY_BREAK
  case 110:
  YY_RULE_SETUP
  #line 235 "chapel.lex"
  return processToken(yyscanner, TMOD);
  	YY_BREAK
  case 111:
  YY_RULE_SETUP
  #line 236 "chapel.lex"
  return processToken(yyscanner, TMINUSMINUS);
  	YY_BREAK
  case 112:
  YY_RULE_SETUP
  #line 237 "chapel.lex"
  return processToken(yyscanner, TPLUSPLUS);
  	YY_BREAK
  case 113:
  YY_RULE_SETUP
  #line 239 "chapel.lex"
  return processToken(yyscanner, TEXP);
  	YY_BREAK
  case 114:
  YY_RULE_SETUP
  #line 241 "chapel.lex"
  return processToken(yyscanner, TCOLON);
  	YY_BREAK
  case 115:
  YY_RULE_SETUP
  #line 242 "chapel.lex"
  return processToken(yyscanner, TSEMI);
  	YY_BREAK
  case 116:
  YY_RULE_SETUP
  #line 243 "chapel.lex"
  return processToken(yyscanner, TCOMMA);
  	YY_BREAK
  case 117:
  YY_RULE_SETUP
  #line 244 "chapel.lex"
  return processToken(yyscanner, TDOT);
  	YY_BREAK
  case 118:
  YY_RULE_SETUP
  #line 245 "chapel.lex"
  return processToken(yyscanner, TLP);
  	YY_BREAK
  case 119:
  YY_RULE_SETUP
  #line 246 "chapel.lex"
  return processToken(yyscanner, TRP);
  	YY_BREAK
  case 120:
  YY_RULE_SETUP
  #line 247 "chapel.lex"
  return processToken(yyscanner, TLSBR);
  	YY_BREAK
  case 121:
  YY_RULE_SETUP
  #line 248 "chapel.lex"
  return processToken(yyscanner, TRSBR);
  	YY_BREAK
  case 122:
  YY_RULE_SETUP
  #line 249 "chapel.lex"
  return processExternCode(yyscanner);
  	YY_BREAK
  case 123:
  YY_RULE_SETUP
  #line 250 "chapel.lex"
  return processToken(yyscanner, TLCBR);
  	YY_BREAK
  case 124:
  YY_RULE_SETUP
  #line 251 "chapel.lex"
  return processToken(yyscanner, TRCBR);
  	YY_BREAK
  case 125:
  YY_RULE_SETUP
  #line 252 "chapel.lex"
  return processToken(yyscanner, TIO);
  	YY_BREAK
  case 126:
  YY_RULE_SETUP
  #line 253 "chapel.lex"
  return processToken(yyscanner, TQUESTION);
  	YY_BREAK
  case 127:
  YY_RULE_SETUP
  #line 255 "chapel.lex"
  return processToken(yyscanner, INTLITERAL);
  	YY_BREAK
  case 128:
  YY_RULE_SETUP
  #line 256 "chapel.lex"
  return processToken(yyscanner, REALLITERAL);
  	YY_BREAK
  case 129:
  YY_RULE_SETUP
  #line 258 "chapel.lex"
  return processToken(yyscanner, IMAGLITERAL);
  	YY_BREAK
  case 130:
  YY_RULE_SETUP
  #line 259 "chapel.lex"
  return processToken(yyscanner, IMAGLITERAL);
  	YY_BREAK
  case 131:
  YY_RULE_SETUP
  #line 261 "chapel.lex"
  return processIdentifier(yyscanner);
  	YY_BREAK
  case 132:
  YY_RULE_SETUP
  #line 262 "chapel.lex"
  return processStringLiteral(yyscanner, "\"", STRINGLITERAL);
  	YY_BREAK
  case 133:
  YY_RULE_SETUP
  #line 263 "chapel.lex"
  return processStringLiteral(yyscanner, "\'", STRINGLITERAL);
  	YY_BREAK
  case 134:
  YY_RULE_SETUP
  #line 264 "chapel.lex"
  return processStringLiteral(yyscanner, "\"", CSTRINGLITERAL);
  	YY_BREAK
  case 135:
  YY_RULE_SETUP
  #line 265 "chapel.lex"
  return processStringLiteral(yyscanner, "\'", CSTRINGLITERAL);
  	YY_BREAK
  case 136:
  YY_RULE_SETUP
  #line 267 "chapel.lex"
  return processSingleLineComment(yyscanner);
  	YY_BREAK
  case 137:
  YY_RULE_SETUP
  #line 268 "chapel.lex"
  return processBlockComment(yyscanner);
  	YY_BREAK
  case 138:
  /* rule 138 can match eol */
  YY_RULE_SETUP
  #line 270 "chapel.lex"
  return processNewline(yyscanner);
  	YY_BREAK
  case 139:
  YY_RULE_SETUP
  #line 272 "chapel.lex"
  processWhitespace(yyscanner);
  	YY_BREAK
  case 140:
  YY_RULE_SETUP
  #line 273 "chapel.lex"
  processInvalidToken(yyscanner);
  	YY_BREAK
  case 141:
  YY_RULE_SETUP
  #line 275 "chapel.lex"
  ECHO;
  	YY_BREAK
  #line 1800 "flex-chapel.cpp"
  case YY_STATE_EOF(INITIAL):
  case YY_STATE_EOF(externmode):
  	yyterminate();
  
  	case YY_END_OF_BUFFER:
  		{
  		/* Amount of text matched not including the EOB char. */
  		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
  
  		/* Undo the effects of YY_DO_BEFORE_ACTION. */
  		*yy_cp = yyg->yy_hold_char;
  		YY_RESTORE_YY_MORE_OFFSET
  
  		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
  			{
  			/* We're scanning a new file or input source.  It's
  			 * possible that this happened because the user
  			 * just pointed yyin at a new source and called
  			 * yylex().  If so, then we have to assure
  			 * consistency between YY_CURRENT_BUFFER and our
  			 * globals.  Here is the right place to do so, because
  			 * this is the first action (other than possibly a
  			 * back-up) that will match for the new input source.
  			 */
  			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
  			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
  			}
  
  		/* Note that here we test for yy_c_buf_p "<=" to the position
  		 * of the first EOB in the buffer, since yy_c_buf_p will
  		 * already have been incremented past the NUL character
  		 * (since all states make transitions on EOB to the
  		 * end-of-buffer state).  Contrast this with the test
  		 * in input().
  		 */
  		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
  			{ /* This was really a NUL. */
  			yy_state_type yy_next_state;
  
  			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
  
  			yy_current_state = yy_get_previous_state( yyscanner );
  
  			/* 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 , yyscanner);
  
  			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
  
  			if ( yy_next_state )
  				{
  				/* Consume the NUL. */
  				yy_cp = ++yyg->yy_c_buf_p;
  				yy_current_state = yy_next_state;
  				goto yy_match;
  				}
  
  			else
  				{
  				yy_cp = yyg->yy_c_buf_p;
  				goto yy_find_action;
  				}
  			}
  
  		else switch ( yy_get_next_buffer( yyscanner ) )
  			{
  			case EOB_ACT_END_OF_FILE:
  				{
  				yyg->yy_did_buffer_switch_on_eof = 0;
  
  				if ( yywrap(yyscanner ) )
  					{
  					/* Note: because we've taken care in
  					 * yy_get_next_buffer() to have set up
  					 * yytext, we can now set up
  					 * yy_c_buf_p so that if some total
  					 * hoser (like flex itself) wants to
  					 * call the scanner after we return the
  					 * YY_NULL, it'll still work - another
  					 * YY_NULL will get returned.
  					 */
  					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
  
  					yy_act = YY_STATE_EOF(YY_START);
  					goto do_action;
  					}
  
  				else
  					{
  					if ( ! yyg->yy_did_buffer_switch_on_eof )
  						YY_NEW_FILE;
  					}
  				break;
  				}
  
  			case EOB_ACT_CONTINUE_SCAN:
  				yyg->yy_c_buf_p =
  					yyg->yytext_ptr + yy_amount_of_matched_text;
  
  				yy_current_state = yy_get_previous_state( yyscanner );
  
  				yy_cp = yyg->yy_c_buf_p;
  				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
  				goto yy_match;
  
  			case EOB_ACT_LAST_MATCH:
  				yyg->yy_c_buf_p =
  				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
  
  				yy_current_state = yy_get_previous_state( yyscanner );
  
  				yy_cp = yyg->yy_c_buf_p;
  				yy_bp = yyg->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 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 (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
  	register char *source = yyg->yytext_ptr;
  	register int number_to_move, i;
  	int ret_val;
  
  	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
  
  	else
  		{
  			yy_size_t 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) (yyg->yy_c_buf_p - b->yy_ch_buf);
  
  			if ( b->yy_is_our_buffer )
  				{
  				yy_size_t 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. */
  					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
  				}
  			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" );
  
  			yyg->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]),
  			yyg->yy_n_chars, num_to_read );
  
  		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
  		}
  
  	if ( yyg->yy_n_chars == 0 )
  		{
  		if ( number_to_move == YY_MORE_ADJ )
  			{
  			ret_val = EOB_ACT_END_OF_FILE;
  			yyrestart(yyin  ,yyscanner);
  			}
  
  		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;
  
  	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
  		/* Extend the array by 50%, plus the number we really need. */
  		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
  		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
  		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
  			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
  	}
  
  	yyg->yy_n_chars += number_to_move;
  	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  
  	yyg->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 (yyscan_t yyscanner)
  {
  	register yy_state_type yy_current_state;
  	register char *yy_cp;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	yy_current_state = yyg->yy_start;
  
  	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->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] )
  			{
  			yyg->yy_last_accepting_state = yy_current_state;
  			yyg->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 >= 385 )
  				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 , yyscan_t yyscanner)
  {
  	register int yy_is_jam;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
  	register char *yy_cp = yyg->yy_c_buf_p;
  
  	register YY_CHAR yy_c = 1;
  	if ( yy_accept[yy_current_state] )
  		{
  		yyg->yy_last_accepting_state = yy_current_state;
  		yyg->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 >= 385 )
  			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 == 384);
  
  	return yy_is_jam ? 0 : yy_current_state;
  }
  
  #ifndef YY_NO_INPUT
  #ifdef __cplusplus
      static int yyinput (yyscan_t yyscanner)
  #else
      static int input  (yyscan_t yyscanner)
  #endif
  
  {
  	int c;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	*yyg->yy_c_buf_p = yyg->yy_hold_char;
  
  	if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
  			/* This was really a NUL. */
  			*yyg->yy_c_buf_p = '\0';
  
  		else
  			{ /* need more input */
  			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
  			++yyg->yy_c_buf_p;
  
  			switch ( yy_get_next_buffer( yyscanner ) )
  				{
  				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. */
  					yyrestart(yyin ,yyscanner);
  
  					/*FALLTHROUGH*/
  
  				case EOB_ACT_END_OF_FILE:
  					{
  					if ( yywrap(yyscanner ) )
  						return 0;
  
  					if ( ! yyg->yy_did_buffer_switch_on_eof )
  						YY_NEW_FILE;
  #ifdef __cplusplus
  					return yyinput(yyscanner);
  #else
  					return input(yyscanner);
  #endif
  					}
  
  				case EOB_ACT_CONTINUE_SCAN:
  					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
  					break;
  				}
  			}
  		}
  
  	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
  	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
  	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
  
  	return c;
  }
  #endif	/* ifndef YY_NO_INPUT */
  
  /** Immediately switch to a different input stream.
   * @param input_file A readable stream.
   * @param yyscanner The scanner object.
   * @note This function does not reset the start condition to @c INITIAL .
   */
      void yyrestart  (FILE * input_file , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	if ( ! YY_CURRENT_BUFFER ){
          yyensure_buffer_stack (yyscanner);
  		YY_CURRENT_BUFFER_LVALUE =
              yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
  	}
  
  	yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
  	yy_load_buffer_state(yyscanner );
  }
  
  /** Switch to a different input buffer.
   * @param new_buffer The new input buffer.
   * @param yyscanner The scanner object.
   */
      void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	/* TODO. We should be able to replace this entire function body
  	 * with
  	 *		yypop_buffer_state();
  	 *		yypush_buffer_state(new_buffer);
       */
  	yyensure_buffer_stack (yyscanner);
  	if ( YY_CURRENT_BUFFER == new_buffer )
  		return;
  
  	if ( YY_CURRENT_BUFFER )
  		{
  		/* Flush out information for old buffer. */
  		*yyg->yy_c_buf_p = yyg->yy_hold_char;
  		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
  		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
  		}
  
  	YY_CURRENT_BUFFER_LVALUE = new_buffer;
  	yy_load_buffer_state(yyscanner );
  
  	/* We don't actually know whether we did this switch during
  	 * EOF (yywrap()) processing, but the only time this flag
  	 * is looked at is after yywrap() is called, so it's safe
  	 * to go ahead and always set it.
  	 */
  	yyg->yy_did_buffer_switch_on_eof = 1;
  }
  
  static void yy_load_buffer_state  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
  	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
  	yyg->yy_hold_char = *yyg->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.
   * @param yyscanner The scanner object.
   * @return the allocated buffer state.
   */
      YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
  {
  	YY_BUFFER_STATE b;
      
  	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
  	if ( ! b )
  		YY_FATAL_ERROR( "out of dynamic memory in 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 *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
  	if ( ! b->yy_ch_buf )
  		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  
  	b->yy_is_our_buffer = 1;
  
  	yy_init_buffer(b,file ,yyscanner);
  
  	return b;
  }
  
  /** Destroy the buffer.
   * @param b a buffer created with yy_create_buffer()
   * @param yyscanner The scanner object.
   */
      void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	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 )
  		yyfree((void *) b->yy_ch_buf ,yyscanner );
  
  	yyfree((void *) b ,yyscanner );
  }
  
  #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 yyrestart() or at EOF.
   */
      static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
  
  {
  	int oerrno = errno;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	yy_flush_buffer(b ,yyscanner);
  
  	b->yy_input_file = file;
  	b->yy_fill_buffer = 1;
  
      /* If b is the current buffer, then yy_init_buffer was _probably_
       * called from 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.
   * @param yyscanner The scanner object.
   */
      void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	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 )
  		yy_load_buffer_state(yyscanner );
  }
  
  /** 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.
   *  @param yyscanner The scanner object.
   */
  void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	if (new_buffer == NULL)
  		return;
  
  	yyensure_buffer_stack(yyscanner);
  
  	/* This block is copied from yy_switch_to_buffer. */
  	if ( YY_CURRENT_BUFFER )
  		{
  		/* Flush out information for old buffer. */
  		*yyg->yy_c_buf_p = yyg->yy_hold_char;
  		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
  		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
  		}
  
  	/* Only push if top exists. Otherwise, replace top. */
  	if (YY_CURRENT_BUFFER)
  		yyg->yy_buffer_stack_top++;
  	YY_CURRENT_BUFFER_LVALUE = new_buffer;
  
  	/* copied from yy_switch_to_buffer. */
  	yy_load_buffer_state(yyscanner );
  	yyg->yy_did_buffer_switch_on_eof = 1;
  }
  
  /** Removes and deletes the top of the stack, if present.
   *  The next element becomes the new top.
   *  @param yyscanner The scanner object.
   */
  void yypop_buffer_state (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	if (!YY_CURRENT_BUFFER)
  		return;
  
  	yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
  	YY_CURRENT_BUFFER_LVALUE = NULL;
  	if (yyg->yy_buffer_stack_top > 0)
  		--yyg->yy_buffer_stack_top;
  
  	if (YY_CURRENT_BUFFER) {
  		yy_load_buffer_state(yyscanner );
  		yyg->yy_did_buffer_switch_on_eof = 1;
  	}
  }
  
  /* Allocates the stack if it does not exist.
   *  Guarantees space for at least one push.
   */
  static void yyensure_buffer_stack (yyscan_t yyscanner)
  {
  	yy_size_t num_to_alloc;
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
  	if (!yyg->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;
  		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
  								(num_to_alloc * sizeof(struct yy_buffer_state*)
  								, yyscanner);
  		if ( ! yyg->yy_buffer_stack )
  			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
  								  
  		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
  				
  		yyg->yy_buffer_stack_max = num_to_alloc;
  		yyg->yy_buffer_stack_top = 0;
  		return;
  	}
  
  	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
  
  		/* Increase the buffer to prepare for a possible push. */
  		int grow_size = 8 /* arbitrary grow size */;
  
  		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
  		yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
  								(yyg->yy_buffer_stack,
  								num_to_alloc * sizeof(struct yy_buffer_state*)
  								, yyscanner);
  		if ( ! yyg->yy_buffer_stack )
  			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
  
  		/* zero only the new slots.*/
  		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
  		yyg->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
   * @param yyscanner The scanner object.
   * @return the newly allocated buffer state object. 
   */
  YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
  {
  	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) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
  	if ( ! b )
  		YY_FATAL_ERROR( "out of dynamic memory in 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;
  
  	yy_switch_to_buffer(b ,yyscanner );
  
  	return b;
  }
  
  /** Setup the input buffer state to scan a string. The next call to yylex() will
   * scan from a @e copy of @a str.
   * @param yystr a NUL-terminated string to scan
   * @param yyscanner The scanner object.
   * @return the newly allocated buffer state object.
   * @note If you want to scan bytes that may contain NUL values, then use
   *       yy_scan_bytes() instead.
   */
  YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
  {
      
  	return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
  }
  
  /** Setup the input buffer state to scan the given bytes. The next call to 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.
   * @param yyscanner The scanner object.
   * @return the newly allocated buffer state object.
   */
  YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
  {
  	YY_BUFFER_STATE b;
  	char *buf;
  	yy_size_t n, i;
      
  	/* Get memory for full buffer, including space for trailing EOB's. */
  	n = _yybytes_len + 2;
  	buf = (char *) yyalloc(n ,yyscanner );
  	if ( ! buf )
  		YY_FATAL_ERROR( "out of dynamic memory in 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 = yy_scan_buffer(buf,n ,yyscanner);
  	if ( ! b )
  		YY_FATAL_ERROR( "bad buffer in 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;
  }
  
      static void yy_push_state (int  new_state , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
  		{
  		yy_size_t new_size;
  
  		yyg->yy_start_stack_depth += YY_START_STACK_INCR;
  		new_size = yyg->yy_start_stack_depth * sizeof( int );
  
  		if ( ! yyg->yy_start_stack )
  			yyg->yy_start_stack = (int *) yyalloc(new_size ,yyscanner );
  
  		else
  			yyg->yy_start_stack = (int *) yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
  
  		if ( ! yyg->yy_start_stack )
  			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
  		}
  
  	yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
  
  	BEGIN(new_state);
  }
  
      static void yy_pop_state  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	if ( --yyg->yy_start_stack_ptr < 0 )
  		YY_FATAL_ERROR( "start-condition stack underflow" );
  
  	BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
  }
  
      static int yy_top_state  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  	return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
  }
  
  #ifndef YY_EXIT_FAILURE
  #define YY_EXIT_FAILURE 2
  #endif
  
  static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
  {
      	(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 yytext. */ \
          int yyless_macro_arg = (n); \
          YY_LESS_LINENO(yyless_macro_arg);\
  		yytext[yyleng] = yyg->yy_hold_char; \
  		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
  		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
  		*yyg->yy_c_buf_p = '\0'; \
  		yyleng = yyless_macro_arg; \
  		} \
  	while ( 0 )
  
  /* Accessor  methods (get/set functions) to struct members. */
  
  /** Get the user-defined data for this scanner.
   * @param yyscanner The scanner object.
   */
  YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yyextra;
  }
  
  /** Get the current line number.
   * @param yyscanner The scanner object.
   */
  int yyget_lineno  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      
          if (! YY_CURRENT_BUFFER)
              return 0;
      
      return yylineno;
  }
  
  /** Get the current column number.
   * @param yyscanner The scanner object.
   */
  int yyget_column  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      
          if (! YY_CURRENT_BUFFER)
              return 0;
      
      return yycolumn;
  }
  
  /** Get the input stream.
   * @param yyscanner The scanner object.
   */
  FILE *yyget_in  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yyin;
  }
  
  /** Get the output stream.
   * @param yyscanner The scanner object.
   */
  FILE *yyget_out  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yyout;
  }
  
  /** Get the length of the current token.
   * @param yyscanner The scanner object.
   */
  yy_size_t yyget_leng  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yyleng;
  }
  
  /** Get the current token.
   * @param yyscanner The scanner object.
   */
  
  char *yyget_text  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yytext;
  }
  
  /** Set the user-defined data. This data is never touched by the scanner.
   * @param user_defined The data to be associated with this scanner.
   * @param yyscanner The scanner object.
   */
  void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yyextra = user_defined ;
  }
  
  /** Set the current line number.
   * @param line_number
   * @param yyscanner The scanner object.
   */
  void yyset_lineno (int  line_number , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
          /* lineno is only valid if an input buffer exists. */
          if (! YY_CURRENT_BUFFER )
             yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner); 
      
      yylineno = line_number;
  }
  
  /** Set the current column.
   * @param line_number
   * @param yyscanner The scanner object.
   */
  void yyset_column (int  column_no , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
          /* column is only valid if an input buffer exists. */
          if (! YY_CURRENT_BUFFER )
             yy_fatal_error( "yyset_column called with no buffer" , yyscanner); 
      
      yycolumn = column_no;
  }
  
  /** Set the input stream. This does not discard the current
   * input buffer.
   * @param in_str A readable stream.
   * @param yyscanner The scanner object.
   * @see yy_switch_to_buffer
   */
  void yyset_in (FILE *  in_str , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yyin = in_str ;
  }
  
  void yyset_out (FILE *  out_str , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yyout = out_str ;
  }
  
  int yyget_debug  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yy_flex_debug;
  }
  
  void yyset_debug (int  bdebug , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yy_flex_debug = bdebug ;
  }
  
  /* Accessor methods for yylval and yylloc */
  
  YYSTYPE * yyget_lval  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yylval;
  }
  
  void yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yylval = yylval_param;
  }
  
  YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      return yylloc;
  }
      
  void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      yylloc = yylloc_param;
  }
      
  /* User-visible API */
  
  /* yylex_init is special because it creates the scanner itself, so it is
   * the ONLY reentrant function that doesn't take the scanner as the last argument.
   * That's why we explicitly handle the declaration, instead of using our macros.
   */
  
  int yylex_init(yyscan_t* ptr_yy_globals)
  
  {
      if (ptr_yy_globals == NULL){
          errno = EINVAL;
          return 1;
      }
  
      *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
  
      if (*ptr_yy_globals == NULL){
          errno = ENOMEM;
          return 1;
      }
  
      /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
      memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
  
      return yy_init_globals ( *ptr_yy_globals );
  }
  
  /* yylex_init_extra has the same functionality as yylex_init, but follows the
   * convention of taking the scanner as the last argument. Note however, that
   * this is a *pointer* to a scanner, as it will be allocated by this call (and
   * is the reason, too, why this function also must handle its own declaration).
   * The user defined value in the first argument will be available to yyalloc in
   * the yyextra field.
   */
  
  int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
  
  {
      struct yyguts_t dummy_yyguts;
  
      yyset_extra (yy_user_defined, &dummy_yyguts);
  
      if (ptr_yy_globals == NULL){
          errno = EINVAL;
          return 1;
      }
  	
      *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
  	
      if (*ptr_yy_globals == NULL){
          errno = ENOMEM;
          return 1;
      }
      
      /* By setting to 0xAA, we expose bugs in
      yy_init_globals. Leave at 0x00 for releases. */
      memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
      
      yyset_extra (yy_user_defined, *ptr_yy_globals);
      
      return yy_init_globals ( *ptr_yy_globals );
  }
  
  static int yy_init_globals (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
      /* Initialization is the same as for the non-reentrant scanner.
       * This function is called from yylex_destroy(), so don't allocate here.
       */
  
      yyg->yy_buffer_stack = 0;
      yyg->yy_buffer_stack_top = 0;
      yyg->yy_buffer_stack_max = 0;
      yyg->yy_c_buf_p = (char *) 0;
      yyg->yy_init = 0;
      yyg->yy_start = 0;
  
      yyg->yy_start_stack_ptr = 0;
      yyg->yy_start_stack_depth = 0;
      yyg->yy_start_stack =  NULL;
  
  /* Defined in main.c */
  #ifdef YY_STDINIT
      yyin = stdin;
      yyout = stdout;
  #else
      yyin = (FILE *) 0;
      yyout = (FILE *) 0;
  #endif
  
      /* For future reference: Set errno on error, since we are called by
       * yylex_init()
       */
      return 0;
  }
  
  /* yylex_destroy is for both reentrant and non-reentrant scanners. */
  int yylex_destroy  (yyscan_t yyscanner)
  {
      struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
  
      /* Pop the buffer stack, destroying each element. */
  	while(YY_CURRENT_BUFFER){
  		yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
  		YY_CURRENT_BUFFER_LVALUE = NULL;
  		yypop_buffer_state(yyscanner);
  	}
  
  	/* Destroy the stack itself. */
  	yyfree(yyg->yy_buffer_stack ,yyscanner);
  	yyg->yy_buffer_stack = NULL;
  
      /* Destroy the start condition stack. */
          yyfree(yyg->yy_start_stack ,yyscanner );
          yyg->yy_start_stack = NULL;
  
      /* Reset the globals. This is important in a non-reentrant scanner so the next time
       * yylex() is called, initialization will occur. */
      yy_init_globals( yyscanner);
  
      /* Destroy the main struct (reentrant only). */
      yyfree ( yyscanner , yyscanner );
      yyscanner = NULL;
      return 0;
  }
  
  /*
   * Internal utility routines.
   */
  
  #ifndef yytext_ptr
  static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
  {
  	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 , yyscan_t yyscanner)
  {
  	register int n;
  	for ( n = 0; s[n]; ++n )
  		;
  
  	return n;
  }
  #endif
  
  void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
  {
  	return (void *) malloc( size );
  }
  
  void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
  {
  	/* 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 yyfree (void * ptr , yyscan_t yyscanner)
  {
  	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
  }
  
  #define YYTABLES_NAME "yytables"
  
  #line 275 "chapel.lex"
  
  
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  #include "countTokens.h"
  #include "misc.h"
  #include "stringutil.h"
  
  #include <cstring>
  #include <cctype>
  #include <string>
  
  static void  newString();
  static void  addString(const char* str);
  static void  addChar(char c);
  static void  addCharString(char c);
  
  static int   getNextYYChar(yyscan_t scanner);
  
  static int   stringBuffLen = 0;
  static int   stringLen     = 0;
  static char* stringBuffer  = NULL;
  
  int processNewline(yyscan_t scanner) {
    YYLTYPE* yyLloc = yyget_lloc(scanner);
  
    chplLineno++;
  
    yyLloc->first_column = 0;
    yyLloc->last_column  = 0;
  
    yyLloc->first_line   = chplLineno;
    yyLloc->last_line    = chplLineno;
  
    countNewline();
  
    return YYLEX_NEWLINE;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  void stringBufferInit() {
    if (stringBuffer == NULL) {
      stringBuffer  = (char*) malloc(1024);
      stringBuffer[0] = '\0';
    }
  }
  
  static int  processIdentifier(yyscan_t scanner) {
    YYSTYPE* yyLval = yyget_lval(scanner);
    int      retval = processToken(scanner, TIDENT);
  
    yyLval->pch = astr(yyget_text(scanner));
  
    return retval;
  }
  
  static int processToken(yyscan_t scanner, int t) {
    YYSTYPE* yyLval = yyget_lval(scanner);
    size_t   remain = sizeof(captureString) - 1;
  
    countToken(yyget_text(scanner));
  
    yyLval->pch = yyget_text(scanner);
  
    if (captureTokens) {
      if (t == TASSIGN ||
          t == TDOTDOTDOT) {
        strncat(captureString, " ",                 remain);
        remain = remain - 1;
      }
  
      if (t != TLCBR) {
        strncat(captureString, yyget_text(scanner), remain);
        remain = remain - strlen(yyget_text(scanner));
      }
  
      if (t == TCOMMA  ||
          t == TPARAM  ||
          t == TZIP    ||
          t == TTYPE   ||
          t == TCONST  ||
          t == TIN     ||
          t == TINOUT  ||
          t == TOUT    ||
          t == TREF    ||
          t == TCOLON  ||
          t == TASSIGN ||
          t == TRSBR) {
        strncat(captureString, " ",                 remain);
        remain = remain - 1;
      }
    }
  
    // If the stack has a value then we must be in externmode.
    // Return to INITIAL
    if (yy_has_state(scanner) == true) {
      yy_pop_state(scanner);
    }
  
    return t;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static char* eatStringLiteral(yyscan_t scanner, const char* startChar);
  
  static int processStringLiteral(yyscan_t scanner, const char* q, int type) {
    const char* yyText = yyget_text(scanner);
    YYSTYPE*    yyLval = yyget_lval(scanner);
  
    yyLval->pch = astr(eatStringLiteral(scanner, q));
  
    countToken(astr(q, yyLval->pch, q));
  
    if (captureTokens) {
      size_t remain = sizeof(captureString) - 1;
  
      strncat(captureString, yyText,      remain);
      remain = remain - strlen(yyText);
  
      strncat(captureString, yyLval->pch, remain);
      remain = remain - strlen(yyLval->pch);
  
      strncat(captureString, yyText,      remain);
      remain = remain - strlen(yyText);
    }
  
    return type;
  }
  
  static char* eatStringLiteral(yyscan_t scanner, const char* startChar) {
    char*      yyText  = yyget_text(scanner);
    YYLTYPE*   yyLloc  = yyget_lloc(scanner);
    const char startCh = *startChar;
    int        c       = 0;
  
    newString();
  
    while ((c = getNextYYChar(scanner)) != startCh && c != 0) {
      if (c == '\n') {
        ParserContext context(scanner);
  
        yyText[0] = '\0';
        yyerror(yyLloc, &context, "end-of-line in a string literal without a preceding backslash");
      } else {
        if (startCh == '\'' && c == '\"') {
          addCharString('\\');
        }
  
        // \ escape ? to avoid C trigraphs
        if (c == '?')
          addCharString('\\');
  
        addCharString(c);
      }
  
      if (c == '\\') {
        c = getNextYYChar(scanner);
  
        if (c == '\n') {
          processNewline(scanner);
          addCharString('n');
        } else if (c == 'u' || c == 'U') {
          ParserContext context(scanner);
          yyerror(yyLloc, &context, "universal character name not yet supported in string literal");
        } else if ('0' <= c && c <= '7' ) {
          ParserContext context(scanner);
          yyerror(yyLloc, &context, "octal escape not supported in string literal");
        } else if (c != 0) {
          addCharString(c);
        }
        else
          break;
      }
    } /* eat up string */
  
    if (c == 0) {
      ParserContext context(scanner);
  
      yyerror(yyLloc, &context, "EOF in string");
    }
  
    return stringBuffer;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static int processExtern(yyscan_t scanner) {
    const char* yyText = yyget_text(scanner);
    YYSTYPE*    yyLval = yyget_lval(scanner);
  
    yyLval->pch = yyget_text(scanner);
  
    countToken(yyText);
  
    if (captureTokens) {
      strncat(captureString, yyText, sizeof(captureString) - 1);
    }
  
    // Push a state to record that "extern" has been seen
    yy_push_state(externmode, scanner);
  
    return TEXTERN;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static char* eatExternCode(yyscan_t scanner);
  
  // When the lexer calls this function, it has already consumed the first '{'
  static int processExternCode(yyscan_t scanner) {
    YYSTYPE* yyLval = yyget_lval(scanner);
  
    yyLval->pch = eatExternCode(scanner);
  
    countToken(astr(yyLval->pch));
  
    if (captureTokens) {
      strncat(captureString, yyLval->pch, sizeof(captureString) - 1);
    }
  
    return EXTERNCODE;
  }
  
  static char* eatExternCode(yyscan_t scanner) {
    const int in_code                          = 0;
    const int in_single_quote                  = 1;
    const int in_single_quote_backslash        = 2;
    const int in_double_quote                  = 3;
    const int in_double_quote_backslash        = 4;
    const int in_single_line_comment           = 5;
    const int in_single_line_comment_backslash = 6;
    const int in_multi_line_comment            = 7;
  
    YYLTYPE*  yyLloc                           = yyget_lloc(scanner);
  
    int       depth                            = 1;
    int       c                                = 0;
    int       lastc                            = 0;
    int       state                            = 0;
  
    newString();
  
    // First, store the line information.
    addString("#line ");
    addString(istr(chplLineno));
    addString(" \"");
    addString(yyfilename);
    addString("\" ");
    addString("\n");
  
    // Now, append the C code until we get to a }.
    while (depth > 0) {
      lastc = c;
      c     = getNextYYChar(scanner);
  
      if (c == 0) {
        ParserContext context(scanner);
  
        switch (state) {
          case in_code:
            // there was no match to the {
            yyerror(yyLloc, &context, "Missing } in extern block");
            break;
  
          case in_single_quote:
          case in_single_quote_backslash:
            yyerror(yyLloc, &context, "Runaway \'string\' in extern block");
            break;
  
          case in_double_quote:
          case in_double_quote_backslash:
            yyerror(yyLloc, &context, "Runaway \"string\" in extern block");
            break;
  
          case in_single_line_comment:
            yyerror(yyLloc, &context, "Missing newline after extern block // comment");
            break;
  
          case in_multi_line_comment:
            yyerror(yyLloc, &context, "Runaway /* comment */ in extern block");
            break;
        }
        break;
      }
  
      addChar(c);
  
      if (c == '\n')
        processNewline(scanner);
  
      // Now update state (are we in a comment? a string?)
      switch (state) {
        case in_code:
          if (c == '\'')
            state = in_single_quote;
  
          else if (c == '"')
            state = in_double_quote;
  
          else if (lastc == '/' && c == '/')
            state = in_single_line_comment;
  
          else if (lastc == '/' && c == '*')
            state = in_multi_line_comment;
  
          else if (c == '{' )
            depth++;
  
          else if (c == '}' )
            depth--;
  
          break;
  
        case in_single_quote:
          if (c == '\\')
            state = in_single_quote_backslash;
  
          else if (c == '\'')
            state = in_code;
  
          break;
  
        case in_single_quote_backslash:
          state = in_single_quote;
          break;
  
        case in_double_quote:
          if (c == '\\')
            state = in_double_quote_backslash;
  
          else if (c == '"')
            state = in_code;
  
          break;
  
        case in_double_quote_backslash:
          state = in_double_quote;
          break;
  
        case in_single_line_comment:
          if (c == '\n')
            state = in_code;
          break;
  
        case in_single_line_comment_backslash:
          if (c == ' ' || c == '\t' || c == '\n')
            state = in_single_line_comment_backslash;
  
          else
            state = in_single_line_comment;
  
          break;
  
        case in_multi_line_comment:
          if (lastc == '*' && c == '/')
            state = in_code;
          break;
      }
    }
  
    //save the C String
    //eliminate the final '{'
    if (stringLen >= 1)
      stringLen -= 1;
  
    stringBuffer[stringLen] = '\0';
  
    return stringBuffer;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static void processWhitespace(yyscan_t scanner) {
    // might eventually want to keep track of column numbers and do
    // something here
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static int processSingleLineComment(yyscan_t scanner) {
    YYSTYPE* yyLval = yyget_lval(scanner);
    int      c      = 0;
  
    newString();
    countCommentLine();
  
    // Read until the end of the line
    while ((c = getNextYYChar(scanner)) != '\n' && c != 0) {
      addChar(c);
    }
  
    countSingleLineComment(stringBuffer);
  
    if (c != 0) {
      processNewline(scanner);
    }
  
    yyLval->pch = astr(stringBuffer);
  
    return YYLEX_SINGLE_LINE_COMMENT;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static int processBlockComment(yyscan_t scanner) {
    YYSTYPE*    yyLval       = yyget_lval(scanner);
    YYLTYPE*    yyLloc       = yyget_lloc(scanner);
  
    int nestedStartLine = -1;
    int startLine = chplLineno;
    const char* startFilename = yyfilename;
  
    int         len          = strlen(fDocsCommentLabel);
    int         labelIndex   = (len >= 2) ? 2 : 0;
  
    int         c            = 0;
    int         lastc        = 0;
    int         depth        = 1;
    std::string wholeComment = "";
  
    newString();
    countCommentLine();
  
    while (depth > 0) {
      int lastlastc = lastc;
  
      lastc = c;
      c     = getNextYYChar(scanner);
  
      if (c == '\n') {
        countMultiLineComment(stringBuffer);
        processNewline(scanner);
  
        if (fDocs && labelIndex == len) {
          wholeComment += stringBuffer;
          wholeComment += '\n';
        }
  
        newString();
        countCommentLine();
      } else {
        if ((labelIndex < len) && (labelIndex != -1)) {
          if (c == fDocsCommentLabel[labelIndex]) {
            labelIndex++;
          } else {
            labelIndex = -1;
          }
        }
  
        addChar(c);
      }
  
      if (lastc == '*' && c == '/' && lastlastc != '/') { // close comment
        depth--;
  
      } else if (lastc == '/' && c == '*') { // start nested
        depth++;
        // keep track of the start of the last nested comment
        nestedStartLine = chplLineno;
      } else if (c == 0) {
        ParserContext context(scanner);
  
        fprintf(stderr, "%s:%d: unterminated comment started here\n",
                startFilename, startLine);
        if( nestedStartLine >= 0 ) {
          fprintf(stderr, "%s:%d: nested comment started here\n",
                  startFilename, nestedStartLine);
        }
        yyerror(yyLloc, &context, "EOF in comment");
      }
    }
  
    // back up two to not print */ again.
    if (stringLen >= 2)
      stringLen -= 2;
  
    // back up further if the user has specified a special form of commenting
    if (len > 2 && labelIndex == len)
      stringLen -= (len - 2);
  
    stringBuffer[stringLen] = '\0';
  
    // Saves the comment grabbed to the comment field of the location struct,
    // for use when the --docs flag is implemented
    if (fDocs && labelIndex == len) {
      wholeComment += stringBuffer;
  
      if (len > 2) {
        len          = len - 2;
        wholeComment = wholeComment.substr(len);
      }
  
      // Also, only need to fix indentation failure when the comment matters
      size_t location = wholeComment.find("\\x09");
  
      while (location != std::string::npos) {
        wholeComment = wholeComment.substr(0, location) + wholeComment.substr(location + 4);
  
        wholeComment.insert(location, "\t");
  
        location = wholeComment.find("\\x09");
      }
  
      yyLval->pch = astr(wholeComment.c_str());
  
    } else {
      yyLval->pch = NULL;
    }
  
    countMultiLineComment(stringBuffer);
  
    newString();
  
    return YYLEX_BLOCK_COMMENT;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static void processInvalidToken(yyscan_t scanner) {
    ParserContext context(scanner);
    YYLTYPE*      yyLloc = yyget_lloc(scanner);
  
    yyerror(yyLloc, &context, "Invalid token");
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static void addCharMaybeEscape(char c, bool canEscape);
  static char toHex(char c);
  
  static void newString() {
    stringLen = 0;
  
    if (stringBuffLen) {
      stringBuffer[0] = '\0';
    }
  }
  
  static void addString(const char* str) {
    for (int i = 0; str[i]; i++)
      addChar(str[i]);
  }
  
  static void addChar(char c) {
    addCharMaybeEscape(c, false);
  }
  
  static void addCharString(char c) {
    addCharMaybeEscape(c, true);
  }
  
  static void addCharMaybeEscape(char c, bool canEscape) {
    int escape  = canEscape && !(isascii(c) && isprint(c));
    int charlen = escape ? 4 : 1; // convert nonascii to \xNN
  
    if (stringLen + charlen + 1 > stringBuffLen) {
      stringBuffLen = 2 * (stringBuffLen + charlen);
      stringBuffer  = (char*) realloc(stringBuffer,
                                      stringBuffLen * sizeof(char));
    }
  
    if (escape) {
      stringBuffer[stringLen++] = '\\';
      stringBuffer[stringLen++] = 'x';
      stringBuffer[stringLen++] = toHex(((unsigned char)c) >> 4);
      stringBuffer[stringLen++] = toHex(c & 0xf);
    } else {
      stringBuffer[stringLen++] = c;
    }
  
    stringBuffer[stringLen] = '\0';
  }
  
  // Returns the hexadecimal character for 0-16.
  static char toHex(char c) {
    return (0 <= c && c <= 9) ? '0' + c : 'A' + (c - 10);
  }
  
  static int getNextYYChar(yyscan_t scanner) {
    int retval = yyinput(scanner);
  
    if (retval == EOF) {
      retval = 0;
    }
  
    return retval;
  }
  
  /************************************ | *************************************
  *                                                                           *
  *                                                                           *
  *                                                                           *
  ************************************* | ************************************/
  
  static bool yy_has_state(yyscan_t yyscanner)
  {
    // This is only to suppress a compiler warning
    (void) yy_top_state;
  
    struct yyguts_t * yyg = (struct yyguts_t*) yyscanner;
  
    return yyg->yy_start_stack_ptr > 0;
  }
  
  