This commit was manufactured by cvs2svn to create tag 'release14'.v1.4

author: cvs2svn <tools@python.org> 1996-10-25 15:40:20 (GMT)
committer: cvs2svn <tools@python.org> 1996-10-25 15:40:20 (GMT)
commit: 6c3a3aa17b028f6b93067083d32c7eaa4338757c (patch)
tree: 416b434cadec883c68be3897203da0aaa9066839 /Grammar
parent: 61f9139125d0b0aadc6f452e197721ec9de9236a (diff)
download: cpython-1.4.zip
cpython-1.4.tar.gz
cpython-1.4.tar.bz2
0 files changed, 0 insertions, 0 deletions
diff --git a/src/Makefile.in b/src/Makefile.in
index 66ff412..8f4c352 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -36,6 +36,8 @@ clean:
 	$(MAKE) -f Makefile.doxygen    clean 
 	$(MAKE) -f Makefile.doxytag    clean
 	$(MAKE) -f Makefile.doxysearch clean
+
+distclean: clean
 	-$(RM) scanner.cpp code.cpp config.cpp pre.cpp ce_lex.cpp \
                ce_parse.cpp ce_parse.h doxytag.cpp tag.cpp \
 	       declinfo.cpp defargs.cpp
diff --git a/src/ce_lex.cpp b/src/ce_lex.cpp
new file mode 100644
index 0000000..7e250ef
--- /dev/null
+++ b/src/ce_lex.cpp
@@ -0,0 +1,1800 @@
+#define yy_create_buffer cppExpYY_create_buffer
+#define yy_delete_buffer cppExpYY_delete_buffer
+#define yy_scan_buffer cppExpYY_scan_buffer
+#define yy_scan_string cppExpYY_scan_string
+#define yy_scan_bytes cppExpYY_scan_bytes
+#define yy_flex_debug cppExpYY_flex_debug
+#define yy_init_buffer cppExpYY_init_buffer
+#define yy_flush_buffer cppExpYY_flush_buffer
+#define yy_load_buffer_state cppExpYY_load_buffer_state
+#define yy_switch_to_buffer cppExpYY_switch_to_buffer
+#define yyin cppExpYYin
+#define yyleng cppExpYYleng
+#define yylex cppExpYYlex
+#define yyout cppExpYYout
+#define yyrestart cppExpYYrestart
+#define yytext cppExpYYtext
+#define yywrap cppExpYYwrap
+
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		*yy_cp = yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+	/* 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
+	};
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* 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".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char *yytext;
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 33
+#define YY_END_OF_BUFFER 34
+static yyconst short int yy_accept[62] =
+    {   0,
+        0,    0,   34,   31,   32,   22,   20,    7,   31,   23,
+       24,   18,   16,   17,   31,   19,   26,   27,    2,   10,
+       31,   11,    1,    6,    5,   21,    8,    4,    0,    0,
+       29,   29,   26,    0,    0,   26,    0,   27,   27,   14,
+       12,    9,   13,   15,    3,   25,    0,    0,    0,    0,
+       29,   29,    0,   30,   28,    0,    0,   29,   30,   28,
+        0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
+        1,    1,    3,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    4,    5,    1,    1,    6,    7,    8,    9,
+       10,   11,   12,    1,   13,   14,   15,   16,   17,   17,
+       17,   17,   17,   17,   17,   18,   18,   19,    1,   20,
+       21,   22,   23,    1,   24,   24,   24,   24,   25,   26,
+        1,    1,    1,    1,    1,   27,    1,    1,    1,    1,
+        1,    1,    1,    1,   28,    1,    1,   29,    1,    1,
+        1,   30,    1,   31,    1,    1,   32,   32,   24,   24,
+
+       25,   33,    1,    1,    1,    1,    1,   27,    1,    5,
+        1,    1,    1,    5,    1,    5,   28,    5,    1,   34,
+        1,    1,    1,   35,    1,   36,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    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 int yy_meta[37] =
+    {   0,
+        1,    2,    2,    1,    1,    1,    1,    2,    1,    1,
+        1,    1,    1,    1,    1,    3,    3,    3,    1,    1,
+        1,    1,    1,    3,    3,    3,    1,    1,    1,    1,
+        1,    3,    3,    1,    1,    1
+    } ;
+
+static yyconst short int yy_base[65] =
+    {   0,
+        0,    0,  130,  163,  163,   88,  163,   92,   65,  163,
+      163,  163,  163,  163,   21,  163,   26,   47,  163,   25,
+       57,   26,  163,  163,   38,  163,  163,  163,   41,   71,
+       90,   40,   33,   52,   68,   55,    0,    0,   63,  163,
+      163,  163,  163,  163,  163,  163,   51,   94,    0,   80,
+      163,    0,  102,  108,   86,   44,  111,  126,  163,   94,
+      163,  159,   47,   38
+    } ;
+
+static yyconst short int yy_def[65] =
+    {   0,
+       61,    1,   61,   61,   61,   61,   61,   61,   62,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   62,   61,
+       61,   31,   17,   61,   61,   61,   63,   18,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   64,   61,
+       61,   32,   61,   61,   63,   64,   61,   61,   61,   61,
+        0,   61,   61,   61
+    } ;
+
+static yyconst short int yy_nxt[200] =
+    {   0,
+        4,    5,    4,    6,    4,    7,    8,    9,   10,   11,
+       12,   13,   14,   15,   16,   17,   18,   18,   19,   20,
+       21,   22,   23,    4,    4,    4,    4,    4,    4,    4,
+       24,    4,    4,    4,   25,   26,   31,   31,   31,   32,
+       56,   33,   33,   34,   40,   41,   43,   44,   46,   55,
+       35,   46,   36,   36,   37,   52,   52,   52,   46,   37,
+       32,   61,   38,   38,   38,   32,   61,   34,   34,   34,
+       61,   35,   45,   39,   39,   47,   35,   42,   47,   53,
+       53,   36,   36,   54,   54,   54,   48,   48,   48,   39,
+       39,   57,   57,   47,   30,   58,   58,   58,   28,   49,
+
+       47,   46,   47,   47,   49,   31,   31,   31,   27,   48,
+       48,   48,   60,   60,   50,   51,   51,   54,   54,   54,
+       60,   60,   51,   54,   54,   54,   58,   58,   58,   61,
+       61,   61,   61,   59,   59,   61,   61,   61,   61,   61,
+       59,   58,   58,   58,   61,   61,   61,   61,   61,   61,
+       61,   51,   51,   61,   61,   61,   61,   61,   51,   29,
+       61,   29,    3,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61
+
+    } ;
+
+static yyconst short int yy_chk[200] =
+    {   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,   15,   15,   15,   17,
+       64,   17,   17,   17,   20,   20,   22,   22,   29,   63,
+       17,   56,   17,   17,   17,   32,   32,   32,   47,   17,
+       18,   33,   18,   18,   18,   34,   33,   34,   34,   34,
+       29,   18,   25,   18,   18,   30,   34,   21,   30,   35,
+       35,   36,   36,   35,   35,   35,   30,   30,   30,   39,
+       39,   50,   50,   30,    9,   50,   50,   50,    8,   30,
+
+       30,   48,   30,   30,   30,   31,   31,   31,    6,   48,
+       48,   48,   55,   55,   31,   31,   31,   53,   53,   53,
+       60,   60,   31,   54,   54,   54,   57,   57,   57,    3,
+        0,    0,    0,   54,   54,    0,    0,    0,    0,    0,
+       54,   58,   58,   58,    0,    0,    0,    0,    0,    0,
+        0,   58,   58,    0,    0,    0,    0,    0,   58,   62,
+        0,   62,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,   61
+
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "constexp.l"
+#define INITIAL 0
+/******************************************************************************
+ *
+ * $Id$
+ *
+ *
+ * Copyright (C) 1997-1999 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+#line 19 "constexp.l"
+
+#include "constexp.h"  
+#include "cppvalue.h"
+#include "ce_parse.h" // generated header file
+
+#define YY_NO_UNPUT
+#define YY_NEVER_INTERACTIVE 1
+  
+QCString strToken;  
+
+static const char *inputString;
+static int         inputPosition;
+CPPValue resultValue;
+
+#undef  YY_INPUT
+#define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
+
+static int yyread(char *buf,int max_size)
+{
+  int c=0;
+  while( c < max_size && inputString[inputPosition] )
+  {
+    *buf = inputString[inputPosition++] ;
+    c++; buf++;
+  }
+  return c;
+}
+
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( 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->yy_is_interactive ) \
+		{ \
+		int c = '*', 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 if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+		  && ferror( yyin ) ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* 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
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+
+#line 49 "constexp.l"
+
+
+
+	if ( yy_init )
+		{
+		yy_init = 0;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! yy_current_buffer )
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+
+		yy_load_buffer_state();
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yy_start;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yy_last_accepting_state = yy_current_state;
+				yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 62 )
+					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] != 163 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+
+do_action:	/* This label is used only to access EOF actions. */
+
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yy_hold_char;
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 51 "constexp.l"
+{ return TOK_QUESTIONMARK; }
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 52 "constexp.l"
+{ return TOK_COLON; }
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 53 "constexp.l"
+{ return TOK_OR; }
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 54 "constexp.l"
+{ return TOK_AND; }
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 55 "constexp.l"
+{ return TOK_BITWISEOR; }
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 56 "constexp.l"
+{ return TOK_BITWISEXOR; }
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 57 "constexp.l"
+{ return TOK_AMPERSAND; }
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 58 "constexp.l"
+{ return TOK_NOTEQUAL; }
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 59 "constexp.l"
+{ return TOK_EQUAL; }
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 60 "constexp.l"
+{ return TOK_LESSTHAN; }
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 61 "constexp.l"
+{ return TOK_GREATERTHAN; }
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 62 "constexp.l"
+{ return TOK_LESSTHANOREQUALTO; }
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 63 "constexp.l"
+{ return TOK_GREATERTHANOREQUALTO; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 64 "constexp.l"
+{ return TOK_SHIFTLEFT; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 65 "constexp.l"
+{ return TOK_SHIFTRIGHT; }
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 66 "constexp.l"
+{ return TOK_PLUS; }
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 67 "constexp.l"
+{ return TOK_MINUS; }
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 68 "constexp.l"
+{ return TOK_STAR; }
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 69 "constexp.l"
+{ return TOK_DIVIDE; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 70 "constexp.l"
+{ return TOK_MOD; }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 71 "constexp.l"
+{ return TOK_TILDE; }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 72 "constexp.l"
+{ return TOK_NOT; }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 73 "constexp.l"
+{ return TOK_LPAREN; }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 74 "constexp.l"
+{ return TOK_RPAREN; }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 75 "constexp.l"
+{ 
+                                     strToken=yytext;  
+				     return TOK_CHARACTER; 
+				   }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 79 "constexp.l"
+{ strToken=yytext; 
+  				     return TOK_OCTALINT; 
+				   }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 82 "constexp.l"
+{ strToken=yytext; 
+  				     return TOK_DECIMALINT; 
+				   }
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 85 "constexp.l"
+{ strToken=yytext; return TOK_HEXADECIMALINT; }
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 86 "constexp.l"
+{ 
+                                     strToken=yytext; return TOK_FLOAT; 
+                                   }
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 89 "constexp.l"
+{ 
+                                     strToken=yytext; return TOK_FLOAT; 
+			           }
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 92 "constexp.l"
+
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 93 "constexp.l"
+
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 95 "constexp.l"
+ECHO;
+	YY_BREAK
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( yy_current_buffer->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.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap() )
+					{
+					/* 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.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of 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()
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr;
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( yy_current_buffer->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->yy_n_chars = yy_n_chars = 0;
+
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
+
+			int yy_c_buf_p_offset =
+				(int) (yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yy_flex_realloc( (void *) b->yy_ch_buf,
+							 b->yy_buf_size + 2 );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
+#endif
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yytext_ptr = &yy_current_buffer->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()
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+
+	yy_current_state = yy_start;
+
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yy_last_accepting_state = yy_current_state;
+			yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 62 )
+				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 );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+	{
+	register int yy_is_jam;
+	register char *yy_cp = yy_c_buf_p;
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yy_last_accepting_state = yy_current_state;
+		yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 62 )
+			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 == 61);
+
+	return yy_is_jam ? 0 : yy_current_state;
+	}
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+	{
+	register char *yy_cp = yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
+
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		yy_current_buffer->yy_n_chars =
+			yy_n_chars = yy_current_buffer->yy_buf_size;
+
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+
+	yytext_ptr = yy_bp;
+	yy_hold_char = *yy_cp;
+	yy_c_buf_p = yy_cp;
+	}
+#endif	/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+	{
+	int c;
+
+	*yy_c_buf_p = yy_hold_char;
+
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = yy_c_buf_p - yytext_ptr;
+			++yy_c_buf_p;
+
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin );
+
+					/* fall through */
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						return EOF;
+
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
+
+
+	return c;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
+
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
+
+	/* 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.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+	{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	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 *) yy_flex_alloc( b->yy_buf_size + 2 );
+	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 );
+
+	return b;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+	{
+	if ( ! b )
+		return;
+
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yy_flex_free( (void *) b->yy_ch_buf );
+
+	yy_flex_free( (void *) b );
+	}
+
+
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+	{
+	yy_flush_buffer( b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+	b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+	b->yy_is_interactive = 0;
+#else
+	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+#endif
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+	{
+	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();
+	}
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+	{
+	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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	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 );
+
+	return b;
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+	{
+	int len;
+	for ( len = 0; yy_str[len]; ++len )
+		;
+
+	return yy_scan_bytes( yy_str, len );
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+	{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = len + 2;
+	buf = (char *) yy_flex_alloc( n );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < len; ++i )
+		buf[i] = bytes[i];
+
+	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n );
+	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;
+	}
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		yy_size_t new_size;
+
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
+
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
+
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
+
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+	}
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+	{
+	(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. */ \
+		yytext[yyleng] = yy_hold_char; \
+		yy_c_buf_p = yytext + n; \
+		yy_hold_char = *yy_c_buf_p; \
+		*yy_c_buf_p = '\0'; \
+		yyleng = n; \
+		} \
+	while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+	{
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+	}
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+	{
+	return (void *) malloc( size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+	{
+	/* 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 );
+	}
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+	{
+	free( ptr );
+	}
+
+#if YY_MAIN
+int main()
+	{
+	yylex();
+	return 0;
+	}
+#endif
+#line 95 "constexp.l"
+
+
+bool parseCppExpression(const QCString &s)
+{
+  //printf("Expression: `%s'\n",s.data());
+  inputString = s;
+  inputPosition = 0;
+  cppExpYYrestart( cppExpYYin );
+  cppExpYYparse();
+  //printf("Result: %ld\n",(long)resultValue);
+  return (long)resultValue!=0;
+}
+
+extern "C" {
+  int cppExpYYwrap() { return 1; }
+}
diff --git a/src/ce_parse.cpp b/src/ce_parse.cpp
new file mode 100644
index 0000000..a494670
--- /dev/null
+++ b/src/ce_parse.cpp
@@ -0,0 +1,1152 @@
+
+/*  A Bison parser, made from constexp.y
+ by  GNU Bison version 1.25
+  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define yyparse cppExpYYparse
+#define yylex cppExpYYlex
+#define yyerror cppExpYYerror
+#define yylval cppExpYYlval
+#define yychar cppExpYYchar
+#define yydebug cppExpYYdebug
+#define yynerrs cppExpYYnerrs
+#define	TOK_QUESTIONMARK	258
+#define	TOK_COLON	259
+#define	TOK_OR	260
+#define	TOK_AND	261
+#define	TOK_BITWISEOR	262
+#define	TOK_BITWISEXOR	263
+#define	TOK_AMPERSAND	264
+#define	TOK_NOTEQUAL	265
+#define	TOK_EQUAL	266
+#define	TOK_LESSTHAN	267
+#define	TOK_GREATERTHAN	268
+#define	TOK_LESSTHANOREQUALTO	269
+#define	TOK_GREATERTHANOREQUALTO	270
+#define	TOK_SHIFTLEFT	271
+#define	TOK_SHIFTRIGHT	272
+#define	TOK_PLUS	273
+#define	TOK_MINUS	274
+#define	TOK_STAR	275
+#define	TOK_DIVIDE	276
+#define	TOK_MOD	277
+#define	TOK_TILDE	278
+#define	TOK_NOT	279
+#define	TOK_LPAREN	280
+#define	TOK_RPAREN	281
+#define	TOK_OCTALINT	282
+#define	TOK_DECIMALINT	283
+#define	TOK_HEXADECIMALINT	284
+#define	TOK_CHARACTER	285
+#define	TOK_FLOAT	286
+
+
+
+#include "cppvalue.h"
+#include "constexp.h"
+
+#if defined(_MSC_VER)
+#define MSDOS
+#endif
+
+#define YYSTYPE CPPValue
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int cppExpYYerror(const char *s)
+{
+  printf("ERROR: %s\n",s);
+  return 0;
+}
+
+int cppExpYYlex();
+
+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+#include <stdio.h>
+
+#ifndef __cplusplus
+#ifndef __STDC__
+#define const
+#endif
+#endif
+
+
+
+#define	YYFINAL		73
+#define	YYFLAG		-32768
+#define	YYNTBASE	32
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 47)
+
+static const char yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
+     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    26,    27,    28,    29,    30,    31
+};
+
+#if YYDEBUG != 0
+static const short yyprhs[] = {     0,
+     0,     2,     4,    10,    12,    16,    18,    22,    24,    28,
+    30,    34,    36,    40,    42,    46,    50,    52,    56,    60,
+    64,    68,    70,    74,    78,    80,    84,    88,    90,    94,
+    98,   102,   104,   107,   110,   113,   116,   118,   122,   124,
+   126,   128,   130
+};
+
+static const short yyrhs[] = {    33,
+     0,    34,     0,    34,     3,    34,     4,    34,     0,    35,
+     0,    34,     5,    35,     0,    36,     0,    35,     6,    36,
+     0,    37,     0,    36,     7,    37,     0,    38,     0,    37,
+     8,    38,     0,    39,     0,    38,     9,    39,     0,    40,
+     0,    39,    11,    40,     0,    39,    10,    40,     0,    41,
+     0,    40,    12,    41,     0,    40,    13,    41,     0,    40,
+    14,    41,     0,    40,    15,    41,     0,    42,     0,    41,
+    16,    42,     0,    41,    17,    42,     0,    43,     0,    42,
+    18,    43,     0,    42,    19,    43,     0,    44,     0,    43,
+    20,    44,     0,    43,    21,    44,     0,    43,    22,    44,
+     0,    45,     0,    18,    44,     0,    19,    44,     0,    23,
+    44,     0,    24,    44,     0,    46,     0,    25,    33,    26,
+     0,    27,     0,    28,     0,    29,     0,    30,     0,    31,
+     0
+};
+
+#endif
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+    74,    78,    80,    89,    91,    97,    99,   105,   107,   114,
+   116,   122,   124,   130,   132,   136,   142,   144,   148,   152,
+   157,   164,   166,   170,   176,   178,   189,   202,   204,   215,
+   228,   236,   238,   240,   247,   251,   257,   259,   263,   265,
+   267,   269,   271
+};
+#endif
+
+
+#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+
+static const char * const yytname[] = {   "$","error","$undefined.","TOK_QUESTIONMARK",
+"TOK_COLON","TOK_OR","TOK_AND","TOK_BITWISEOR","TOK_BITWISEXOR","TOK_AMPERSAND",
+"TOK_NOTEQUAL","TOK_EQUAL","TOK_LESSTHAN","TOK_GREATERTHAN","TOK_LESSTHANOREQUALTO",
+"TOK_GREATERTHANOREQUALTO","TOK_SHIFTLEFT","TOK_SHIFTRIGHT","TOK_PLUS","TOK_MINUS",
+"TOK_STAR","TOK_DIVIDE","TOK_MOD","TOK_TILDE","TOK_NOT","TOK_LPAREN","TOK_RPAREN",
+"TOK_OCTALINT","TOK_DECIMALINT","TOK_HEXADECIMALINT","TOK_CHARACTER","TOK_FLOAT",
+"start","constant_expression","logical_or_expression","logical_and_expression",
+"inclusive_or_expression","exclusive_or_expression","and_expression","equality_expression",
+"relational_expression","shift_expression","additive_expression","multiplicative_expression",
+"unary_expression","primary_expression","constant", NULL
+};
+#endif
+
+static const short yyr1[] = {     0,
+    32,    33,    33,    34,    34,    35,    35,    36,    36,    37,
+    37,    38,    38,    39,    39,    39,    40,    40,    40,    40,
+    40,    41,    41,    41,    42,    42,    42,    43,    43,    43,
+    43,    44,    44,    44,    44,    44,    45,    45,    46,    46,
+    46,    46,    46
+};
+
+static const short yyr2[] = {     0,
+     1,     1,     5,     1,     3,     1,     3,     1,     3,     1,
+     3,     1,     3,     1,     3,     3,     1,     3,     3,     3,
+     3,     1,     3,     3,     1,     3,     3,     1,     3,     3,
+     3,     1,     2,     2,     2,     2,     1,     3,     1,     1,
+     1,     1,     1
+};
+
+static const short yydefact[] = {     0,
+     0,     0,     0,     0,     0,    39,    40,    41,    42,    43,
+     1,     2,     4,     6,     8,    10,    12,    14,    17,    22,
+    25,    28,    32,    37,    33,    34,    35,    36,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,    38,     0,
+     5,     7,     9,    11,    13,    16,    15,    18,    19,    20,
+    21,    23,    24,    26,    27,    29,    30,    31,     0,     3,
+     0,     0,     0
+};
+
+static const short yydefgoto[] = {    71,
+    11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+    21,    22,    23,    24
+};
+
+static const short yypact[] = {   -13,
+   -13,   -13,   -13,   -13,   -13,-32768,-32768,-32768,-32768,-32768,
+-32768,     4,     2,    20,    27,    31,    21,     7,    17,    18,
+     8,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    24,   -13,
+   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
+   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,-32768,    34,
+     2,    20,    27,    31,    21,     7,     7,    17,    17,    17,
+    17,    18,    18,     8,     8,-32768,-32768,-32768,   -13,    39,
+    13,    51,-32768
+};
+
+static const short yypgoto[] = {-32768,
+    47,   -26,    25,    23,    26,    28,    22,     5,   -15,     6,
+     9,    -1,-32768,-32768
+};
+
+
+#define	YYLAST		62
+
+
+static const short yytable[] = {    25,
+    26,    27,    28,    50,     1,     2,    30,    32,    31,     3,
+     4,     5,    72,     6,     7,     8,     9,    10,    38,    39,
+    40,    41,    58,    59,    60,    61,    33,    46,    47,    48,
+    36,    37,    42,    43,    34,    44,    45,    69,    31,    35,
+    56,    57,    70,    31,    66,    67,    68,    62,    63,    49,
+    73,    29,    64,    65,    52,    51,    55,     0,    53,     0,
+     0,    54
+};
+
+static const short yycheck[] = {     1,
+     2,     3,     4,    30,    18,    19,     3,     6,     5,    23,
+    24,    25,     0,    27,    28,    29,    30,    31,    12,    13,
+    14,    15,    38,    39,    40,    41,     7,    20,    21,    22,
+    10,    11,    16,    17,     8,    18,    19,     4,     5,     9,
+    36,    37,    69,     5,    46,    47,    48,    42,    43,    26,
+     0,     5,    44,    45,    32,    31,    35,    -1,    33,    -1,
+    -1,    34
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
+#include <alloca.h>
+#else /* not sparc */
+#if defined (MSDOS) && !defined (__TURBOC__)
+#include <malloc.h>
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+#include <malloc.h>
+ #pragma alloca
+#else /* not MSDOS, __TURBOC__, or _AIX */
+#ifdef __hpux
+#ifdef __cplusplus
+extern "C" {
+void *alloca (unsigned int);
+};
+#else /* not __cplusplus */
+void *alloca ();
+#endif /* not __cplusplus */
+#endif /* __hpux */
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc.  */
+#endif /* not GNU C.  */
+#endif /* alloca not defined.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYACCEPT	return(0)
+#define YYABORT 	return(1)
+#define YYERROR		goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+#define YYFAIL		goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    { yychar = (token), yylval = (value);			\
+      yychar1 = YYTRANSLATE (yychar);				\
+      YYPOPSTACK;						\
+      goto yybackup;						\
+    }								\
+  else								\
+    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
+while (0)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#ifndef YYPURE
+#define YYLEX		yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#ifdef YYLEX_PARAM
+#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
+#else
+#define YYLEX		yylex(&yylval, &yylloc)
+#endif
+#else /* not YYLSP_NEEDED */
+#ifdef YYLEX_PARAM
+#define YYLEX		yylex(&yylval, YYLEX_PARAM)
+#else
+#define YYLEX		yylex(&yylval)
+#endif
+#endif /* not YYLSP_NEEDED */
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int	yychar;			/*  the lookahead symbol		*/
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
+#endif
+
+int yynerrs;			/*  number of parse errors so far       */
+#endif  /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
+#ifndef	YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+#ifndef YYPARSE_RETURN_TYPE
+#define YYPARSE_RETURN_TYPE int
+#endif
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
+YYPARSE_RETURN_TYPE yyparse (void);
+#endif
+
+#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
+#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
+#else				/* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_memcpy (to, from, count)
+     char *to;
+     char *from;
+     int count;
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_memcpy (char *to, char *from, int count)
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#endif
+#endif
+
+
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+   into yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
+
+#ifdef YYPARSE_PARAM
+#ifdef __cplusplus
+#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL
+#else /* not __cplusplus */
+#define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+#endif /* not __cplusplus */
+#else /* not YYPARSE_PARAM */
+#define YYPARSE_PARAM_ARG
+#define YYPARSE_PARAM_DECL
+#endif /* not YYPARSE_PARAM */
+
+YYPARSE_RETURN_TYPE
+yyparse(YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+
+#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+#define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylloc;
+#endif
+#endif
+
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int yylen;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+      short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *yyls1 = yyls;
+#endif
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+#ifdef YYLSP_NEEDED
+      /* This used to be a conditional around just the two extra args,
+	 but that might be undefined if yyoverflow is a macro.  */
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yyls1, size * sizeof (*yylsp),
+		 &yystacksize);
+#else
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yystacksize);
+#endif
+
+      yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+      yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+	{
+	  yyerror("parser stack overflow");
+	  return 2;
+	}
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+	yystacksize = YYMAXDEPTH;
+      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+      __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
+      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+      __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+      __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+      if (yyssp >= yyss + yystacksize - 1)
+	YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+  goto yybackup;
+ yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+	{
+	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
+#ifdef YYPRINT
+	  YYPRINT (stderr, yychar, yylval);
+#endif
+	  fprintf (stderr, ")\n");
+	}
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  if (yylen > 0)
+    yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      int i;
+
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       yyn, yyrline[yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+
+  switch (yyn) {
+
+case 1:
+{ resultValue = yyvsp[0]; return 0; ;
+    break;}
+case 2:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 3:
+{
+		       bool c = (yyvsp[-4].isInt() ? ((long)yyvsp[-4] != 0) : ((double)yyvsp[-4] != 0.0));
+		       yyval = c ? yyvsp[-2] : yyvsp[0];
+	             ;
+    break;}
+case 4:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 5:
+{
+			 yyval = CPPValue( (long)((long)yyvsp[-2] || (long)yyvsp[0]) );
+		       ;
+    break;}
+case 6:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 7:
+{
+			  yyval = CPPValue( (long)((long)yyvsp[-2] && (long)yyvsp[0]) );
+			;
+    break;}
+case 8:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 9:
+{ 
+			   yyval = CPPValue( (long)yyvsp[-2] | (long)yyvsp[0] );
+			 ;
+    break;}
+case 10:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 11:
+{
+			   yyval = CPPValue( (long)yyvsp[-2] ^ (long)yyvsp[0] );
+			 ;
+    break;}
+case 12:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 13:
+{ 
+		  yyval = CPPValue( (long)yyvsp[-2] & (long)yyvsp[0] );
+		;
+    break;}
+case 14:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 15:
+{ 
+		       yyval = CPPValue( (long)((double)yyvsp[-2] == (double)yyvsp[0]) );
+	             ;
+    break;}
+case 16:
+{
+                       yyval = CPPValue( (long)((double)yyvsp[-2] != (double)yyvsp[0]) );
+		     ;
+    break;}
+case 17:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 18:
+{ 
+			 yyval = CPPValue( (long)((double)yyvsp[-2] < (double)yyvsp[0]) );
+		       ;
+    break;}
+case 19:
+{
+                         yyval = CPPValue( (long)((double)yyvsp[-2] > (double)yyvsp[0]) );
+		       ;
+    break;}
+case 20:
+{
+		         yyval = CPPValue( (long)((double)yyvsp[-2] <= (double)yyvsp[0]) );
+		       ;
+    break;}
+case 21:
+{
+			 yyval = CPPValue( (long)((double)yyvsp[-2] >= (double)yyvsp[0]) );
+		       ;
+    break;}
+case 22:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 23:
+{
+		    yyval = CPPValue( (long)yyvsp[-2] << (long)yyvsp[0] );	
+		  ;
+    break;}
+case 24:
+{
+		    yyval = CPPValue( (long)yyvsp[-2] >> (long)yyvsp[0] );
+		  ;
+    break;}
+case 25:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 26:
+{
+		       if (!yyvsp[-2].isInt() || !yyvsp[0].isInt())
+		       {
+		         yyval = CPPValue( (double)yyvsp[-2] + (double)yyvsp[0] );
+		       }
+		       else	
+		       {
+		         yyval = CPPValue( (long)yyvsp[-2] + (long)yyvsp[0] );
+		       }
+		     ;
+    break;}
+case 27:
+{
+		       if (!yyvsp[-2].isInt() || !yyvsp[0].isInt())
+		       {
+		         yyval = CPPValue( (double)yyvsp[-2] - (double)yyvsp[0] );
+		       }
+		       else	
+		       {
+		         yyval = CPPValue( (long)yyvsp[-2] - (long)yyvsp[0] );
+		       }
+		     ;
+    break;}
+case 28:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 29:
+{ 
+			     if (!yyvsp[-2].isInt() || !yyvsp[0].isInt())
+			     {
+			       yyval = CPPValue( (double)yyvsp[-2] * (double)yyvsp[0] );
+			     }
+			     else
+			     {
+			       yyval = CPPValue( (long)yyvsp[-2] * (long)yyvsp[0] );
+			     }
+			   ;
+    break;}
+case 30:
+{ 
+			     if (!yyvsp[-2].isInt() || !yyvsp[0].isInt())
+			     {
+			       yyval = CPPValue( (double)yyvsp[-2] / (double)yyvsp[0] );
+			     }
+			     else
+			     {
+			       long value = yyvsp[0];
+			       if (value==0) value=1;
+			       yyval = CPPValue( (long)yyvsp[-2] / value );
+			     }
+			   ;
+    break;}
+case 31:
+{ 
+			     long value = yyvsp[0];
+			     if (value==0) value=1;
+			     yyval = CPPValue( (long)yyvsp[-2] % value );
+			   ;
+    break;}
+case 32:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 33:
+{ yyval = yyvsp[-1]; ;
+    break;}
+case 34:
+{ 
+		    if (yyvsp[0].isInt()) 
+                      yyval = CPPValue(-(long)yyvsp[0]);
+                    else
+		      yyval = CPPValue(-(double)yyvsp[0]);
+		  ;
+    break;}
+case 35:
+{
+		    yyval = CPPValue(~(long)yyvsp[0]);
+		  ;
+    break;}
+case 36:
+{
+		    yyval = CPPValue((long)!(long)yyvsp[0]);
+		  ;
+    break;}
+case 37:
+{ yyval = yyvsp[0]; ;
+    break;}
+case 38:
+{ yyval = yyvsp[-1]; ;
+    break;}
+case 39:
+{ yyval = parseOctal(); ;
+    break;}
+case 40:
+{ yyval = parseDecimal(); ;
+    break;}
+case 41:
+{ yyval = parseHexadecimal(); ;
+    break;}
+case 42:
+{ yyval = parseCharacter(); ;
+    break;}
+case 43:
+{ yyval = parseFloat(); ;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+	  for (x = (yyn < 0 ? -yyn : 0);
+	       x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+	  msg = (char *) malloc(size + 15);
+	  if (msg != 0)
+	    {
+	      strcpy(msg, "parse error");
+
+	      if (count < 5)
+		{
+		  count = 0;
+		  for (x = (yyn < 0 ? -yyn : 0);
+		       x < (sizeof(yytname) / sizeof(char *)); x++)
+		    if (yycheck[x + yyn] == x)
+		      {
+			strcat(msg, count == 0 ? ", expecting `" : " or `");
+			strcat(msg, yytname[x]);
+			strcat(msg, "'");
+			count++;
+		      }
+		}
+	      yyerror(msg);
+	      free(msg);
+	    }
+	  else
+	    yyerror ("parse error; also virtual memory exceeded");
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	yyerror("parse error");
+    }
+
+  goto yyerrlab1;
+yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+}
+
diff --git a/src/ce_parse.h b/src/ce_parse.h
new file mode 100644
index 0000000..913f9ce
--- /dev/null
+++ b/src/ce_parse.h
@@ -0,0 +1,35 @@
+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+#define	TOK_QUESTIONMARK	258
+#define	TOK_COLON	259
+#define	TOK_OR	260
+#define	TOK_AND	261
+#define	TOK_BITWISEOR	262
+#define	TOK_BITWISEXOR	263
+#define	TOK_AMPERSAND	264
+#define	TOK_NOTEQUAL	265
+#define	TOK_EQUAL	266
+#define	TOK_LESSTHAN	267
+#define	TOK_GREATERTHAN	268
+#define	TOK_LESSTHANOREQUALTO	269
+#define	TOK_GREATERTHANOREQUALTO	270
+#define	TOK_SHIFTLEFT	271
+#define	TOK_SHIFTRIGHT	272
+#define	TOK_PLUS	273
+#define	TOK_MINUS	274
+#define	TOK_STAR	275
+#define	TOK_DIVIDE	276
+#define	TOK_MOD	277
+#define	TOK_TILDE	278
+#define	TOK_NOT	279
+#define	TOK_LPAREN	280
+#define	TOK_RPAREN	281
+#define	TOK_OCTALINT	282
+#define	TOK_DECIMALINT	283
+#define	TOK_HEXADECIMALINT	284
+#define	TOK_CHARACTER	285
+#define	TOK_FLOAT	286
+
+
+extern YYSTYPE cppExpYYlval;
diff --git a/src/classdef.cpp b/src/classdef.cpp
index 457a06b..4db552e 100644
--- a/src/classdef.cpp
+++ b/src/classdef.cpp
@@ -29,6 +29,8 @@
 #include "diagram.h"
 #include "language.h"
 #include "htmlhelp.h"
+#include "example.h"
+#include "outputlist.h"
 
 static QCString stripExtension(const char *fName)
 {
@@ -73,6 +75,7 @@ ClassDef::ClassDef(const char *nm,CompoundType ct,const char *ref,const char *fN
   tempArgs=0;
   prot=Public;
   nspace=0;
+  fileDef=0;
 }
 
 // destroy the class definition
@@ -262,19 +265,12 @@ void ClassDef::writeDocumentation(OutputList &ol)
     if (incName.isNull()) nm=incFile->name();
     ol.startTypewriter();
     ol.docify("#include <");
-    ol.disable(OutputGenerator::Man);
-    if (Config::verbatimHeaderFlag)
-    {
-      ol.writeObjectLink(0,fileName+"-include",0,nm);
-    }
-    else
-    {
-      ol.docify(nm);
-    }
-    ol.enable(OutputGenerator::Man);
-    ol.disableAllBut(OutputGenerator::Man);
+    ol.disable(OutputGenerator::Html);
     ol.docify(nm);
     ol.enableAll();
+    ol.disableAllBut(OutputGenerator::Html);
+    ol.writeObjectLink(0,fileName+"-include",0,nm);
+    ol.enableAll();
     ol.docify(">");
     ol.endTypewriter();
     ol.newParagraph();
@@ -420,7 +416,10 @@ void ClassDef::writeDocumentation(OutputList &ol)
     
   // write detailed description
   bool exampleFlag=hasExamples();
-  if (!briefDescription().isEmpty() || !documentation().isEmpty() || exampleFlag)
+  if (!briefDescription().isEmpty() || 
+      !documentation().isEmpty() || 
+      (bodyLine!=-1 && bodyDef) ||
+      exampleFlag)
   {
     ol.writeRuler();
     bool latexOn = ol.isEnabled(OutputGenerator::Latex);
@@ -495,6 +494,7 @@ void ClassDef::writeDocumentation(OutputList &ol)
       //ol.endDescItem();
       ol.endDescList();
     }
+    writeSourceRef(ol);
   }
   
   pubMembers.countDocMembers();
@@ -841,7 +841,7 @@ void ClassDef::writeIncludeFile(OutputList &ol)
   parseText(ol,n);
   endTitle(ol,0,0);
   parseText(ol,theTranslator->trVerbatimText(incFile->name()));
-  ol.writeRuler();
+  //ol.writeRuler();
   ol.startCodeFragment();
   parseCode(ol,n,fileToString(incFile->absFilePath()),FALSE,0);
   ol.endCodeFragment();
@@ -1034,3 +1034,23 @@ void ClassDef::writeDeclaration(OutputList &ol,MemberDef *md)
   friends.writePlainDeclarations(ol,this,0,0);
   related.writePlainDeclarations(ol,this,0,0); 
 }
+
+/*! a link to this class is possible within this project */
+bool ClassDef::isLinkableInProject() 
+{ 
+  return !name().isEmpty() && name().find('@')==-1 && 
+    (prot!=Private || Config::extractPrivateFlag) &&
+    hasDocumentation() && !isReference();
+}
+
+/*! the class is visible in a class diagram, or class hierarchy */
+bool ClassDef::isVisibleInHierarchy() 
+{ return // show all classes or a superclass is visible
+  (Config::allExtFlag || hasNonReferenceSuperClass()) &&
+    // and not an annonymous compound
+    name().find('@')==-1 &&
+    // and not privately inherited
+    (prot!=Private || Config::extractPrivateFlag) &&
+    // documented or show anyway or documentation is external 
+    (hasDocumentation() || !Config::hideClassFlag || isReference());
+}
diff --git a/src/classdef.h b/src/classdef.h
index afdcffb..890cc4a 100644
--- a/src/classdef.h
+++ b/src/classdef.h
@@ -17,18 +17,13 @@
 #ifndef CLASSDEF_H
 #define CLASSDEF_H
 
-//#include <qtstream.h>
 #include "qtbc.h"
-#include <qfileinf.h>
 #include <qlist.h>
 #include <qdict.h>
 #include <qstrlist.h>
 
-#include "membername.h"
-#include "memberlist.h"
-#include "memberdef.h"
-#include "example.h"
 #include "entry.h"
+#include "memberlist.h"
 #include "definition.h"
 
 typedef QDict<MemberDef> MemberDict;
@@ -40,6 +35,9 @@ class MemberInfoList;
 class MemberInfoDict;
 class NamespaceDef;
 class MemberDef;
+class ExampleList;
+class MemberNameInfoList;
+class MemberNameInfoDict;
 
 class ClassDef : public Definition
 {
@@ -50,13 +48,10 @@ class ClassDef : public Definition
                         Union=Entry::UNION_SEC,
                         Interface=Entry::INTERFACE_SEC
                       };
-    
     ClassDef(const char *name,CompoundType ct,const char *ref=0,const char *fName=0);
    ~ClassDef();
-    //QCString classFile() const { return fileName; }
     QCString getOutputFileBase() const { return fileName; }
     CompoundType compoundType() const { return compType; } 
-    //const char *memberListFileName() const { return memListFileName; }
     void insertBaseClass(ClassDef *,Protection p,Specifier s,const char *t=0);
     BaseClassList *baseClasses() { return inherits; }
     void insertSuperClass(ClassDef *,Protection p,Specifier s,const char *t=0);
@@ -66,8 +61,6 @@ class ClassDef : public Definition
     void setIncludeName(const char *n_) { incName=n_; }
     MemberNameInfoList *memberNameInfoList() { return allMemberNameInfoList; }
     MemberNameInfoDict *memberNameInfoDict() { return allMemberNameInfoDict; }
-    //bool isReference() { return !reference.isNull(); }
-    //const char *getReference() const { return reference; }
     void insertMember(const MemberDef *);
     void insertUsedFile(const char *);
     void computeAnchors();
@@ -83,14 +76,7 @@ class ClassDef : public Definition
     //void writeExample(OutputList &ol);
     void setProtection(Protection p) { prot=p; }
     Protection protection() const { return prot; }
-    /*! a link to this class is possible within this project */
-    bool isLinkableInProject() 
-    { //int i = name().findRev("::");
-      //if (i==-1) i=0; else i+=2;
-      return !name().isEmpty() && name().find('@')==-1 && 
-             (prot!=Private || Config::extractPrivateFlag) &&
-             hasDocumentation() && !isReference();
-    }
+    bool isLinkableInProject();
     /*! a link to this class is possible (either within this project,
      *  or as a cross-reference to another project
      */
@@ -100,16 +86,7 @@ class ClassDef : public Definition
     }
     bool hasNonReferenceSuperClass();
     /*! the class is visible in a class diagram, or class hierarchy */
-    bool isVisibleInHierarchy() 
-    { return // show all classes or a superclass is visible
-             (Config::allExtFlag || hasNonReferenceSuperClass()) &&
-             // and not an annonymous compound
-             name().find('@')==-1 &&
-             // and not privately inherited
-             (prot!=Private || Config::extractPrivateFlag) &&
-             // documented or show anyway or documentation is external 
-             (hasDocumentation() || !Config::hideClassFlag || isReference());
-    }
+    bool isVisibleInHierarchy();
     
     // template argument functions
     ArgumentList *templateArguments() const { return tempArgs; }
@@ -117,16 +94,15 @@ class ClassDef : public Definition
     //QCString getTemplateNameString();
     void setNamespace(NamespaceDef *nd) { nspace = nd; }
     NamespaceDef *getNamespace() { return nspace; }
+    void setFileDef(FileDef *fd) { fileDef=fd; }
+    FileDef *getFileDef() const { return fileDef; }
     
     bool visited;
    
   private: 
-    //QCString name;                       // name of the class
     QCString fileName;                   // HTML containing the class docs
-    //QCString doc;                        // general class documentation
     FileDef *incFile;                   // header file to refer to
     QCString incName;                    // alternative include file name
-    //QCString brief;                      // brief class discription
     QCString memListFileName;            
     BaseClassList *inherits;
     BaseClassList *inheritedBy;
@@ -147,11 +123,11 @@ class ClassDef : public Definition
     MemberNameInfoDict *allMemberNameInfoDict;
     ArgumentList     *tempArgs;
     QStrList          files;
-    //QCString           reference;
     ExampleList      *exampleList;
     ExampleDict      *exampleDict;
     CompoundType      compType;
     Protection        prot;
+    FileDef          *fileDef;
 };
 
 
diff --git a/src/code.cpp b/src/code.cpp
new file mode 100644
index 0000000..c71b3f6
--- /dev/null
+++ b/src/code.cpp
@@ -0,0 +1,3534 @@
+#define yy_create_buffer codeYY_create_buffer
+#define yy_delete_buffer codeYY_delete_buffer
+#define yy_scan_buffer codeYY_scan_buffer
+#define yy_scan_string codeYY_scan_string
+#define yy_scan_bytes codeYY_scan_bytes
+#define yy_flex_debug codeYY_flex_debug
+#define yy_init_buffer codeYY_init_buffer
+#define yy_flush_buffer codeYY_flush_buffer
+#define yy_load_buffer_state codeYY_load_buffer_state
+#define yy_switch_to_buffer codeYY_switch_to_buffer
+#define yyin codeYYin
+#define yyleng codeYYleng
+#define yylex codeYYlex
+#define yyout codeYYout
+#define yyrestart codeYYrestart
+#define yytext codeYYtext
+
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		*yy_cp = yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
+		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+	/* 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
+	};
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* 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".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+
+#define YY_USES_REJECT
+
+#define yywrap() 1
+#define YY_SKIP_YYWRAP
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char *yytext;
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 76
+#define YY_END_OF_BUFFER 77
+static yyconst short int yy_acclist[760] =
+    {   0,
+       31,   31,   77,   75,   76,   66,   74,   76,    1,   75,
+       76,   75,   76,   75,   76,   75,   76,   31,   75,   76,
+       31,   66,   74,   76,    1,   31,   75,   76,   33,   75,
+       76,   31,   75,   76,   75,   76,   31,   75,   76,   31,
+       75,   76,    6,   75,   76,    8,   66,   74,   76,    1,
+        6,   75,   76,    6,   75,   76,    6,   75,   76,    6,
+       75,   76,    6,   75,   76,   56,   75,   76,   56,   75,
+       76,    1,   56,   75,   76,   75,   76,   75,   76,   56,
+       75,   76,   75,   76,   75,   76,   58,   66,   74,   76,
+        1,   75,   76,   75,   76,   75,   76,   75,   76,   62,
+
+       65,   75,   76,   64,   66,   74,   76,    1,   62,   65,
+       75,   76,   65,   75,   76,   62,   65,   75,   76,   62,
+       65,   75,   76,   62,   65,   75,   76,   75,   76,   66,
+       74,   76,    1,   75,   76,   30,   75,   76,   75,   76,
+       40,   75,   76,   75,   76,   37,   75,   76,   41,   75,
+       76,   35,   75,   76, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413, 8220,
+       75,   76,16412,16413, 8220,   75,   76,16412,16413,   10,
+       75,   76,   11,   75,   76,   75,   76,   75,   76,    5,
+       75,   76,   44,   75,   76,   45,   75,   76,   43,   75,
+       76,   42,   75,   76,16436,   39,   75,   76,   39,   75,
+       76,   66,   74,   76,    1,   39,   75,   76,   30,   39,
+       75,   76,   39,   75,   76,   39,   75,   76,   75,   76,
+    16422,   39,   75,   76,   39,   75,   76,   39,   75,   76,
+       42,   75,   76,16437,16438,   50,   75,   76,   49,   75,
+
+       76,   75,   76,   66,   74,   76,   13,   75,   76,   15,
+       75,   76,   12,   75,   76,   14,   75,   76,   16,   75,
+       76,   75,   76,   75,   76,   25,   75,   76,   22,   75,
+       76,   21,   75,   76,   21,   75,   76,   21,   75,   76,
+       75,   76,   23,   75,   76,   24,   75,   76,   75,   76,
+    16388,   72,   73,   72,   73,   31,   31,   31,   31,   32,
+       72,   31,   32,   73,   34,   31,   31,   31,   32,   72,
+       31,   32,   73,    9,   73,    7,    9,   73,   56,   56,
+       57,   55,   73,   56,   55,   73,   58,   72,   73,   72,
+       73,   62,   61,   63,   72,   62,   63,   73,   62,   62,
+
+       63,   72,   62,   63,   73,   37,   41, 8220, 8220, 8221,
+     8220,16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413,   27, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,16413,
+     8220,16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413, 8220,16412,16413,    5,   48,   46,
+       47,   51, 8244,   42,16436,   42, 8230,16422,16422, 8245,
+     8246,   42,16437,16438,   50,   15,   16,   13,   15,   14,
+
+       16,   21,   21,   21,   21, 8196,16388,   31,   31,   31,
+       31,   31,   31,   31,   31,   60,   62,   62,   62,   36,
+     8220,16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413, 8220,16412,16413,   27, 8220,   27,
+     8220,   26, 8221, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,16413,
+     8220,16412,16413, 8220, 8220, 8220,16412,16413,16422,16422,
+       21,   21,   21,   21,16388,   71,   68,   70,   71,   67,
+
+       68,   31,   31,   31,   71,   31,   31,   68,   31,   31,
+       31,   70,   71,   31,   31,   67,   68,   71,   58,   71,
+       58,   68,   70,   71,   58,   70,   71,   58,   67,   68,
+       60,   62,   62,   62, 8220,16412,16413, 8220,16412,16413,
+     8220,16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413,   26, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413, 8220,16412,16413,   21,   21,   21,   21,   69,   66,
+       70,   67,   31,   69,   31,   31,   66,   31,   70,   31,
+       31,   67,   70,   58,   70,   58,   67,   62, 8220,16412,
+
+    16413, 8220,16412,16413, 8220,16412,16413, 8220,16412,16413,
+     8220,16412,16413, 8220,16412,16413, 8220,16412,16413, 8220,
+    16412,16413,   21,   21,   21,   21,   31,   31,    3, 8220,
+        3, 8220, 8220,16412,16413, 8220,16412,16413, 8220,16412,
+    16413,   21,   21,   18,   21,   21,   59, 8220,16412,16413,
+       20,   21,   21,   17,   21,   21,   19,   21,    2
+    } ;
+
+static yyconst short int yy_accept[446] =
+    {   0,
+        1,    1,    1,    2,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    4,    6,    9,   12,   14,   16,   18,
+       21,   25,   29,   32,   35,   37,   40,   43,   46,   50,
+       54,   57,   60,   63,   66,   69,   72,   76,   78,   80,
+       83,   85,   87,   91,   94,   96,   98,  100,  104,  108,
+      113,  116,  120,  124,  128,  130,  133,  136,  139,  141,
+      144,  146,  149,  152,  155,  160,  165,  170,  175,  180,
+      185,  190,  195,  200,  205,  210,  215,  220,  225,  230,
+
+      233,  236,  238,  240,  243,  246,  249,  252,  256,  259,
+      262,  265,  269,  273,  276,  279,  282,  285,  288,  291,
+      296,  299,  302,  304,  307,  310,  313,  316,  319,  322,
+      324,  326,  329,  332,  335,  338,  341,  343,  346,  349,
+      352,  352,  352,  353,  354,  354,  354,  355,  356,  357,
+      358,  359,  362,  365,  366,  367,  368,  371,  374,  376,
+      377,  379,  380,  381,  381,  382,  384,  385,  387,  387,
+      388,  389,  390,  390,  390,  391,  392,  393,  394,  396,
+      399,  400,  401,  403,  406,  406,  406,  406,  406,  407,
+      408,  408,  409,  410,  411,  414,  417,  420,  423,  426,
+
+      429,  432,  435,  439,  442,  445,  448,  451,  454,  457,
+      460,  463,  466,  469,  472,  475,  475,  478,  478,  479,
+      479,  479,  480,  481,  482,  483,  483,  484,  486,  487,
+      487,  487,  487,  487,  487,  488,  489,  489,  490,  490,
+      490,  491,  491,  492,  495,  496,  496,  496,  497,  498,
+      498,  499,  500,  501,  502,  502,  502,  503,  504,  505,
+      506,  506,  507,  508,  508,  508,  508,  508,  508,  508,
+      508,  508,  508,  509,  510,  511,  512,  513,  514,  515,
+      516,  516,  516,  516,  516,  516,  516,  516,  517,  518,
+      519,  520,  521,  521,  524,  524,  527,  530,  533,  536,
+
+      539,  542,  545,  548,  550,  552,  554,  557,  560,  563,
+      566,  569,  572,  575,  578,  581,  584,  585,  586,  589,
+      589,  589,  590,  590,  590,  591,  592,  593,  594,  595,
+      596,  596,  596,  597,  597,  598,  598,  598,  600,  600,
+      602,  603,  604,  606,  607,  609,  610,  611,  614,  615,
+      618,  619,  621,  621,  623,  623,  623,  625,  628,  628,
+      631,  631,  632,  632,  633,  634,  635,  638,  641,  644,
+      647,  650,  653,  654,  657,  660,  663,  666,  669,  672,
+      675,  675,  676,  677,  678,  679,  680,  680,  681,  682,
+      682,  683,  685,  686,  688,  690,  691,  693,  694,  696,
+
+      696,  698,  698,  699,  702,  705,  708,  711,  714,  717,
+      720,  723,  723,  724,  725,  726,  727,  727,  727,  728,
+      729,  729,  731,  733,  736,  739,  742,  742,  743,  744,
+      746,  747,  748,  751,  751,  753,  754,  756,  756,  757,
+      757,  759,  759,  760,  760
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    5,    6,    7,    1,    1,    8,    9,   10,
+       11,   12,    1,   13,   14,   15,   16,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
+       21,   22,    1,    1,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       21,   24,    1,    1,   23,    1,   25,   26,   27,   28,
+
+       29,   30,   31,   32,   33,   23,   34,   35,   36,   37,
+       38,   39,   23,   40,   41,   42,   43,   44,   45,   23,
+       46,   23,   47,    1,   48,   49,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    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 int yy_meta[50] =
+    {   0,
+        1,    2,    3,    4,    1,    5,    1,    1,    1,    6,
+        1,    7,    1,    8,    9,   10,   11,   12,    1,    1,
+        1,   13,   14,   15,   14,   14,   14,   14,   14,   14,
+       14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
+       14,   14,   14,   14,   14,   14,    1,    1,   16
+    } ;
+
+static yyconst short int yy_base[499] =
+    {   0,
+        0,    3,    5,   11,   20,   29,   35,   38,   45,   53,
+       55,   60,   62,   71,   87,   18,  136,   10,  185,   44,
+      229,   66,  275,   68,  324,  234,  373,  235,  420,  423,
+      445,  237, 1494, 2018,  428, 2018,    6,  493,   65,    0,
+      494,    0, 2018,   67,    0,  495,  226, 2018,  496, 2018,
+      228, 1490,  497,  229,    0,  426,    0, 1476,  231,  502,
+      417, 1487,  499, 1482,  504,  503,  505,    0,  520,    0,
+     1466,  419,  521,  425,  522,  525,  528, 2018,    0, 2018,
+     1457, 2018, 1459, 1457,  545,  548,  513,  532,  531,  536,
+      501,  521,  535,  539,  552,  542,  556,  549,  562, 2018,
+
+     2018,  531,  604, 1472, 2018,  598, 2018,  600, 2018,  621,
+      624,  628, 2018,  597, 1455,  631,  634,  648,  631,  653,
+        0, 2018,  651,  656,  636,   83, 2018,    0, 1470,  659,
+      498, 2018, 2018,    0,  206, 1438,  663, 2018, 2018,  654,
+      596,  666,  668,  676,  681,  672,  681,  680,    0,  685,
+      678,  690,  684, 2018,  689,  687,  699,  702,  703, 2018,
+      704,    0,  617, 1454, 2018,  707,  712,  710, 1466, 2018,
+      722,  726,  714,  729,  732,  733,    0,  500,  728,  734,
+      741,  735,  741,  743,  752, 1450,  758, 1454, 2018, 1443,
+      761,  765,  769, 2018,  391,  741,  747,  737,  750,  756,
+
+      757,  766,  801,  765,  772,  775,  778,  783,  787,  796,
+      800,  804,  793,  805,  816,  849,  852,  861, 1457, 1425,
+      864, 2018, 2018, 2018, 2018, 1435, 2018,  860,    0,  869,
+     1437,  882,  886,  889, 2018,  892,  910,    0,  913,  918,
+     2018, 1416, 2018,  924,    0,  858,  906,  719, 1424,  934,
+      823,  783,    0, 1420,  938,  711,    0,  868, 1371, 1354,
+      928, 2018,  937,    0,  790,  853,    0, 1387,  913,  941,
+        0, 1371,  943,  942,  954,  958,  957,  958,  965,  962,
+      964, 1367,  985,  988,  980, 1357,  878,  992,   40,  968,
+      802, 2018,  996,  779,  999,  968,  980,  981,  985,  908,
+
+      974,  988,  989, 1031, 1034, 2018, 1010, 1005,  984,  999,
+     1013, 1016, 1020, 1021, 1027, 1031, 1073,  920, 1075, 1221,
+     1077, 1084, 1087,  977, 1082, 1213, 1213, 1219, 1211, 1087,
+        0, 1248, 2018, 1220, 2018,    0, 1218, 2018, 1213, 2018,
+     1092, 1093,    0, 1094,    0, 1095, 1107,    0, 1109,    0,
+     1211, 2018, 1187, 2018, 1057, 1172, 1146, 2018, 1127, 2018,
+     1118, 1120, 1112, 1102, 1125, 1126, 1098, 1103, 1084, 1107,
+     1102, 1110, 2018, 1114, 1115, 1120, 1119, 1131, 1128, 1137,
+     1079, 1057, 1042, 1034, 1004, 2018, 1017, 1165, 2018, 1016,
+     2018,    0, 1167, 1166,    0, 1173,    0, 1004, 2018,  969,
+
+     2018, 1172, 1180, 1183, 1152, 1153, 1158, 1161, 1164, 1168,
+     1174,  910,  877,  876,  870,  831, 1206,  736, 1211,  641,
+        0, 1226, 1216, 1169, 1190, 1205,  578,  575,  519,    0,
+      503, 2018, 1196,  220,    0,   51,    0,    1,    0, 1236,
+        0, 1239, 2018, 2018, 1259, 1275, 1291, 1307, 1323, 1339,
+     1355, 1371, 1387, 1403, 1419, 1435, 1450, 1463, 1472, 1485,
+     1498, 1511, 1229, 1236, 1238, 1521, 1534, 1549, 1553, 1566,
+     1581, 1587, 1601, 1617, 1633, 1649, 1665, 1681, 1697, 1713,
+     1729, 1745, 1761, 1777, 1793, 1809, 1825, 1841, 1857, 1873,
+     1889, 1905, 1921, 1937, 1953, 1969, 1985, 2001
+
+    } ;
+
+static yyconst short int yy_def[499] =
+    {   0,
+      445,  445,  446,  446,  447,  447,  448,  448,  449,  449,
+      450,  450,  445,  445,  444,   15,  444,   17,  444,   19,
+       17,   21,  444,   23,  444,   25,  444,   27,  445,  445,
+      444,   31,  444,  444,  444,  444,  444,  444,  444,  451,
+      451,  451,  444,  451,  452,  451,  451,  444,  444,  444,
+      444,  444,  444,  444,  453,  453,  453,  444,  444,  453,
+      444,  454,  444,  454,  454,  454,  454,  455,  444,  455,
+      444,  455,  455,  455,  444,  444,  444,  444,  456,  444,
+      444,  444,  444,  444,  457,  457,   86,   86,   86,   86,
+       86,   86,   86,   86,   86,   86,   86,   86,   86,  444,
+
+      444,  458,  444,  444,  444,  444,  444,  459,  444,  444,
+      444,  444,  444,  444,  444,  460,  461,  444,  444,  462,
+      463,  444,  444,  444,  444,  444,  444,  464,  444,  444,
+      444,  444,  444,  465,  465,  465,  444,  444,  444,  466,
+      444,  444,  444,  444,  444,  444,  444,  444,  451,  451,
+      451,  451,  451,  444,  451,  451,  451,  451,  444,  444,
+      444,  453,  453,  444,  444,  444,  453,  444,  454,  444,
+      454,  454,  454,  454,  454,  454,  455,  444,  444,  455,
+      455,  455,  444,  455,  444,  444,  444,  444,  444,  444,
+      467,  444,  444,  444,   86,   86,   86,   86,   86,   86,
+
+       86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
+       86,   86,   86,   86,   86,  458,  468,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  459,  469,  444,
+      444,  444,  470,  444,  444,  460,  461,  471,  444,  444,
+      444,  444,  444,  462,  463,  444,  444,  444,  444,  444,
+      444,  444,  464,  444,  444,  444,  465,  465,  465,  465,
+      444,  444,  466,  472,  444,  444,  473,  474,  444,  444,
+      475,  476,  451,  451,  477,  478,  451,  451,  479,  480,
+      481,  482,  454,  454,  483,  484,  444,  444,  485,  455,
+      486,  444,  467,   86,  458,   86,   86,   86,   86,   86,
+
+       86,   86,   86,  444,  444,  444,   86,   86,   86,   86,
+       86,   86,   86,   86,   86,   86,  444,  444,  468,  444,
+      470,  460,  461,  444,  471,  465,  465,  465,  465,  472,
+      487,  488,  444,  474,  444,  489,  490,  444,  476,  444,
+      491,  492,  451,  478,  451,  493,  494,  451,  480,  451,
+      454,  444,  482,  444,  495,  496,  454,  444,  484,  444,
+      444,  444,  444,  485,  497,  486,   86,   86,   86,   86,
+       86,   86,  444,   86,   86,   86,   86,   86,   86,   86,
+      444,  465,  465,  465,  465,  444,  488,  444,  444,  490,
+      444,  451,  492,  451,  451,  494,  451,  454,  444,  496,
+
+      444,  444,  497,   86,   86,   86,   86,   86,   86,   86,
+       86,  444,  465,  465,  465,  465,  444,  444,  451,  451,
+      498,  444,  444,   86,   86,   86,  444,  465,  465,  465,
+      465,  444,   86,  444,  465,  465,  465,  444,  465,  444,
+      465,  444,  444,    0,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444
+
+    } ;
+
+static yyconst short int yy_nxt[2068] =
+    {   0,
+      444,  324,   35,   36,   38,   35,   36,   41,   42,  235,
+       43,   38,   46,   41,   42,   37,   43,  143,   39,  103,
+       44,  144,   49,   50,  104,   39,   47,  441,   45,  440,
+       53,   49,   50,   39,   45,   51,   56,   35,   57,   60,
+       35,   57,  335,   52,   54,  118,   58,   63,   64,   58,
+       59,  334,   52,   61,   66,   63,   64,   69,   70,  119,
+       65,   73,   69,   70,   35,   36,   71,   38,   67,   38,
+       72,   71,   38,   35,   36,   74,  147,   37,  152,  439,
+      148,   39,  153,   39,  252,  252,   39,   34,   75,   76,
+       77,   34,   78,   34,   34,   79,   34,   34,   34,   80,
+
+       81,   82,   37,   83,   84,   80,   34,   80,   34,   85,
+       34,   86,   87,   88,   89,   90,   91,   92,   85,   93,
+       85,   85,   85,   94,   85,   85,   95,   96,   97,   98,
+       85,   99,   85,  100,  101,  102,   34,   34,   35,   36,
+       34,   78,   34,   34,   34,  105,  106,   34,  107,   34,
+       34,   37,   34,   34,   34,   34,   34,   34,  108,   34,
+      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
+      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
+      108,  108,   34,   34,   34,  109,  110,  111,  112,  109,
+      113,  109,  109,  109,   34,  109,  109,  109,  109,  109,
+
+      114,   34,  115,  109,  109,  109,  109,  116,  109,  116,
+      116,  116,  116,  116,  116,  116,  116,  116,  116,  116,
+      116,  116,  116,  116,  116,  116,  116,  116,  116,  116,
+      116,  109,  109,  117,   34,  130,  137,  157,   38,  143,
+      147,  158,  143,  159,  161,  258,  166,  438,  259,   39,
+       39,  120,   39,  120,  120,  120,  120,  120,  120,  120,
+      120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
+      120,  120,  120,  120,  120,   34,   34,   35,   36,   34,
+       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
+       37,   34,   34,   34,   34,   34,   34,  121,   34,  121,
+
+      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
+      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
+      121,  122,   34,   34,   34,  123,  124,   36,   34,   34,
+       34,  125,   34,   34,   34,  125,   34,   34,   34,   37,
+       34,  126,  127,   34,   34,   34,  128,   34,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
+      129,   34,   34,   34,  131,   35,   36,   34,   34,   34,
+       34,   34,   34,   34,   34,  132,   34,   34,   37,   34,
+       34,   34,  133,   34,   34,  134,   34,  134,  134,  134,
+
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  135,  134,  134,  134,  134,  136,  134,  134,  129,
+       34,   34,   35,   36,   38,   35,   36,  163,  147,  141,
+      179,  195,  168,  195,  180,   37,  183,  164,   39,  138,
+      184,  139,  138,  142,  139,   34,   34,   35,   36,   34,
+       34,   34,   34,   34,   34,   34,   34,   34,   34,  140,
+       37,  140,   34,   34,   34,   34,   34,  140,   34,  140,
+      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
+      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
+      140,   34,   34,   34,  145,  150,  155,  141,  145,  256,
+
+      141,  287,  288,  167,  173,  170,  170,  170,  146,  151,
+      156,  142,  146,  164,  142,  171,  175,  146,  174,  172,
+      176,  141,  181,  185,  185,  185,  187,  185,  185,  185,
+      185,  185,  216,  216,  216,  142,  182,  437,  205,  186,
+      142,  195,  186,  195,  249,  186,  192,  193,  185,  192,
+      193,  185,  198,  195,  194,  195,  199,  194,  206,  202,
+      436,  195,  186,  195,  203,  186,  200,  207,  203,  201,
+      204,  195,  195,  195,  195,  195,  195,  195,  195,  195,
+      208,  195,  195,  209,  195,  214,  210,  211,  196,  195,
+      197,  195,  195,  215,  195,  212,  195,  141,  195,  221,
+
+      221,  213,  195,  435,  195,  218,  185,  185,  143,  225,
+      219,  142,  144,  226,  227,  222,  223,  229,  163,  146,
+      434,  186,  230,  230,  230,  232,  230,  230,  164,  230,
+      230,  230,  234,  230,  230,  237,  237,  237,  231,  142,
+      235,  231,  147,  251,  224,  231,  148,  251,  231,  239,
+      230,  230,  246,  247,  240,  240,  274,  250,  247,  262,
+      255,  247,  241,  146,  261,  231,  242,  243,  248,  264,
+      229,  142,  267,  248,  146,  262,  248,  265,  146,  267,
+      268,  266,  145,  269,  272,  271,  150,  270,  276,  273,
+      155,  268,  271,  274,  275,  272,  146,  249,  277,  276,
+
+      151,  275,  278,  279,  156,  249,  280,  268,  272,  249,
+      279,  268,  256,  167,  272,  173,  170,  280,  268,  272,
+      252,  252,  268,  164,  170,  272,  281,  146,  170,  174,
+      282,  170,  267,  281,  170,  170,  285,  286,  289,  267,
+      283,  282,  181,  285,  284,  271,  269,  291,  286,  289,
+      290,  266,  271,  185,  185,  185,  182,  249,  291,  187,
+      185,  185,  293,  293,  293,  297,  192,  193,  185,  186,
+      193,  193,  185,  142,  194,  186,  203,  195,  186,  195,
+      300,  195,  186,  195,  252,  252,  186,  195,  296,  195,
+      298,  299,  195,  301,  331,  302,  195,  195,  195,  195,
+
+      303,  331,  304,  305,  340,  307,  195,  195,  195,  295,
+      306,  203,  195,  339,  195,  195,  308,  195,  195,  195,
+      195,  195,  203,  195,  309,  195,  310,  195,  311,  195,
+      251,  314,  312,  195,  251,  195,  195,  315,  195,  313,
+      195,  195,  195,  195,  195,  195,  195,  195,  316,  203,
+      216,  216,  216,  317,  318,  431,  195,  332,  195,  246,
+      247,  194,  218,  185,  185,  221,  221,  219,  332,  225,
+      230,  230,  230,  226,  227,  248,  146,  229,  186,  287,
+      288,  222,  223,  232,  230,  230,  231,  321,  321,  321,
+      234,  230,  230,  234,  230,  230,  430,  142,  235,  231,
+
+      326,  235,  429,  231,  249,  327,  231,  247,  247,  231,
+      224,  237,  237,  237,  239,  230,  230,  336,  428,  240,
+      240,  318,  318,  248,  336,  240,  240,  241,  146,  261,
+      231,  242,  243,  241,  323,  250,  247,  242,  243,  255,
+      247,  229,  262,  146,  427,  337,  342,  341,  369,  142,
+      195,  248,  264,  146,  341,  248,  337,  342,  262,  333,
+      345,  346,  347,  334,  350,  149,  352,  339,  346,  149,
+      338,  401,  365,  347,  249,  169,  149,  333,  324,  169,
+      149,  334,  358,  365,  249,  339,  235,  170,  338,  355,
+      170,  169,  356,  361,  362,  169,  355,  293,  293,  293,
+
+      216,  216,  216,  356,  367,  203,  170,  363,  195,  203,
+      195,  368,  371,  186,  195,  370,  195,  372,  391,  388,
+      195,  195,  195,  195,  195,  195,  374,  195,  195,  195,
+      195,  195,  304,  305,  185,  305,  305,  185,  203,  195,
+      306,  375,  203,  373,  295,  195,  416,  195,  186,  378,
+      195,  186,  195,  195,  376,  195,  203,  377,  195,  399,
+      195,  195,  195,  195,  379,  380,  415,  195,  169,  195,
+      414,  195,  169,  195,  317,  318,  317,  318,  321,  321,
+      321,  413,  194,  324,  194,  234,  230,  230,  237,  237,
+      237,  235,  262,  235,  231,  394,  345,  386,  387,  334,
+
+      389,  231,  264,  149,  335,  412,  149,  149,  262,  397,
+      149,  350,  390,  334,  339,  386,  387,  334,  389,  361,
+      362,  361,  362,  402,  404,  323,  195,  391,  340,  360,
+      390,  203,  339,  363,  203,  363,  390,  339,  195,  405,
+      195,  409,  195,  195,  406,  195,  410,  195,  170,  195,
+      195,  407,  195,  408,  195,  195,  195,  195,  411,  195,
+      195,  195,  195,  203,  404,  203,  417,  419,  195,  394,
+      195,  195,  387,  195,  401,  397,  421,  195,  390,  195,
+      418,  420,  391,  421,  422,  423,  203,  425,  424,  354,
+      387,  390,  195,  195,  195,  195,  390,  203,  195,  203,
+
+      195,  195,  426,  195,  195,  404,  195,  417,  195,  195,
+      195,  433,  419,  170,  195,  340,  195,  423,  423,  185,
+      391,  418,  335,  195,  203,  195,  420,  422,  423,  185,
+      195,  203,  195,  186,  203,  194,  195,  442,  195,  245,
+      442,  443,  245,  186,  443,  195,  253,  195,  257,  253,
+      388,  257,  385,  384,  383,  443,  382,  381,  443,   34,
+       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
+       34,   34,   34,   34,   34,   40,   40,   40,   40,   40,
+       40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
+       40,   48,   48,   48,   48,   48,   48,   48,   48,   48,
+
+       48,   48,   48,   48,   48,   48,   48,   55,   55,   55,
+       55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
+       55,   55,   55,   62,   62,   62,   62,   62,   62,   62,
+       62,   62,   62,   62,   62,   62,   62,   62,   62,   68,
+       68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
+       68,   68,   68,   68,   68,  149,  149,  149,  149,  360,
+      149,  149,  149,  149,  149,  149,  149,  149,  149,  354,
+      149,  154,  154,  340,  154,  154,  154,  154,  154,  154,
+      154,  154,  154,  154,  154,  154,  154,  162,  162,  335,
+      162,  162,  162,  329,  162,  162,  328,  162,  162,  162,
+
+      162,  162,  162,  169,  169,  169,  169,  169,  169,  169,
+      169,  169,  169,  169,  169,  169,  169,  169,  169,  177,
+      177,  254,  177,  177,  177,  254,  177,  177,  177,  177,
+      177,  177,  177,  177,  177,  188,  188,  243,  188,  188,
+      188,  188,  188,  188,  188,  188,  188,  188,  188,  188,
+      188,  195,  195,  195,  233,  195,  227,  320,  220,  190,
+      195,  195,  292,  195,  217,  217,  217,  191,  170,  165,
+      260,  254,  233,  220,  191,  190,  217,  228,  189,  228,
+      228,  178,  228,  228,  170,  228,  236,  236,  236,  170,
+      236,  165,  160,  444,  444,  236,  236,  444,  236,  238,
+
+      238,  238,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  238,  244,  244,  444,  444,  244,  444,  244,  244,
+      444,  244,  244,  444,  244,  263,  444,  444,  444,  263,
+      263,  263,  444,  263,  263,  294,  294,  294,  444,  444,
+      444,  444,  444,  444,  444,  294,  444,  294,  444,  294,
+      319,  319,  444,  444,  319,  444,  444,  444,  444,  319,
+      444,  444,  319,  229,  229,  444,  229,  322,  322,  322,
+      444,  444,  444,  444,  444,  444,  444,  322,  444,  322,
+      444,  322,  325,  444,  444,  444,  325,  444,  444,  444,
+      444,  325,  444,  444,  325,  330,  444,  330,  444,  444,
+
+      330,  333,  333,  333,  333,  333,  333,  444,  333,  333,
+      444,  333,  333,  333,  333,  333,  333,  334,  334,  334,
+      334,  334,  334,  334,  334,  334,  334,  334,  334,  334,
+      334,  334,  334,  338,  338,  338,  338,  338,  338,  444,
+      338,  338,  444,  338,  338,  338,  338,  338,  338,  339,
+      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
+      339,  339,  339,  339,  339,  343,  343,  343,  343,  343,
+      343,  343,  343,  343,  343,  343,  343,  343,  343,  343,
+      343,  344,  344,  344,  344,  344,  344,  344,  344,  344,
+      344,  344,  344,  344,  344,  344,  344,  348,  348,  348,
+
+      348,  348,  348,  348,  348,  348,  348,  348,  348,  348,
+      348,  348,  348,  349,  349,  349,  349,  349,  349,  349,
+      349,  349,  349,  349,  349,  349,  349,  349,  349,  351,
+      351,  351,  351,  351,  351,  351,  351,  351,  351,  351,
+      351,  351,  351,  351,  351,  353,  353,  353,  353,  353,
+      353,  353,  353,  353,  353,  353,  353,  353,  353,  353,
+      353,  357,  357,  357,  357,  357,  357,  357,  357,  357,
+      357,  357,  357,  357,  357,  357,  357,  359,  359,  359,
+      359,  359,  359,  359,  359,  359,  359,  359,  359,  359,
+      359,  359,  359,  364,  364,  364,  364,  364,  364,  364,
+
+      364,  364,  364,  364,  364,  364,  364,  364,  364,  366,
+      366,  366,  366,  366,  366,  366,  366,  366,  366,  366,
+      366,  366,  366,  366,  366,  386,  386,  386,  386,  386,
+      386,  444,  386,  386,  444,  386,  386,  386,  386,  386,
+      386,  387,  387,  387,  387,  387,  387,  387,  387,  387,
+      387,  387,  387,  387,  387,  387,  387,  389,  389,  389,
+      389,  389,  389,  444,  389,  389,  444,  389,  389,  389,
+      389,  389,  389,  390,  390,  390,  390,  390,  390,  390,
+      390,  390,  390,  390,  390,  390,  390,  390,  390,  392,
+      392,  392,  392,  392,  392,  392,  392,  392,  392,  392,
+
+      392,  392,  392,  392,  392,  393,  393,  393,  393,  393,
+      393,  393,  393,  393,  393,  393,  393,  393,  393,  393,
+      393,  395,  395,  395,  395,  395,  395,  395,  395,  395,
+      395,  395,  395,  395,  395,  395,  395,  396,  396,  396,
+      396,  396,  396,  396,  396,  396,  396,  396,  396,  396,
+      396,  396,  396,  398,  398,  398,  398,  398,  398,  398,
+      398,  398,  398,  398,  398,  398,  398,  398,  398,  400,
+      400,  400,  400,  400,  400,  400,  400,  400,  400,  400,
+      400,  400,  400,  400,  400,  403,  403,  403,  403,  403,
+      403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
+
+      403,  432,  432,  432,  432,  432,  432,  444,  432,  432,
+      444,  432,  432,  432,  432,  432,  432,   33,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444
+    } ;
+
+static yyconst short int yy_chk[2068] =
+    {   0,
+        0,  238,    1,    1,    2,    2,    2,    3,    3,  238,
+        3,   18,    4,    4,    4,    1,    4,   37,    2,   16,
+        3,   37,    5,    5,   16,   18,    4,  439,    3,  438,
+        6,    6,    6,   16,    4,    5,    7,    7,    7,    8,
+        8,    8,  289,    5,    6,   20,    7,    9,    9,    8,
+        7,  289,    6,    8,   10,   10,   10,   11,   11,   20,
+        9,   12,   12,   12,   13,   13,   11,   22,   10,   24,
+       11,   12,   14,   14,   14,   12,   39,   13,   44,  436,
+       39,   22,   44,   24,  126,  126,   14,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   21,   26,   28,   47,   32,   51,
+       54,   47,   59,   51,   54,  135,   59,  434,  135,   26,
+       28,   21,   32,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   25,   25,   27,   27,   27,   27,   27,   27,   27,
+       27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
+       27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
+
+       27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
+       27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
+       27,   27,   29,   29,   30,   30,   30,   56,   61,   35,
+       72,  195,   61,  195,   72,   29,   74,   56,   30,   29,
+       74,   29,   30,   35,   30,   31,   31,   31,   31,   31,
+       31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
+       31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
+       31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
+       31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
+       31,   31,   31,   31,   38,   41,   46,   49,   53,  131,
+
+       63,  178,  178,   60,   66,   66,   65,   67,   38,   41,
+       46,   49,   53,   60,   63,   65,   67,   60,   66,   65,
+       67,   69,   73,   75,   75,   75,   76,   76,   76,   77,
+       77,   77,  102,  102,  102,   69,   73,  431,   91,   75,
+       76,   91,   76,   91,  131,   77,   85,   85,   85,   86,
+       86,   86,   87,   87,   85,   87,   88,   86,   92,   89,
+      429,   92,   85,   92,   93,   86,   88,   94,   89,   88,
+       90,   89,   88,   89,   88,   93,   90,   93,   90,   94,
+       95,   94,   96,   96,   96,   98,   96,   97,   86,   98,
+       86,   98,   95,   99,   95,   97,   97,  141,   97,  106,
+
+      106,   97,   99,  428,   99,  103,  103,  103,  114,  108,
+      103,  141,  114,  108,  108,  106,  106,  108,  163,  103,
+      427,  103,  110,  110,  110,  111,  111,  111,  163,  112,
+      112,  112,  116,  116,  116,  117,  117,  117,  110,  111,
+      116,  111,  119,  125,  106,  112,  119,  125,  116,  118,
+      118,  118,  123,  123,  120,  120,  420,  124,  124,  140,
+      130,  130,  120,  118,  137,  118,  120,  120,  123,  140,
+      120,  124,  143,  124,  130,  140,  130,  142,  137,  143,
+      144,  142,  145,  146,  148,  147,  150,  146,  153,  151,
+      155,  144,  147,  151,  152,  148,  145,  123,  156,  153,
+
+      150,  152,  156,  157,  155,  130,  158,  159,  161,  137,
+      157,  166,  256,  167,  168,  173,  173,  158,  159,  161,
+      248,  248,  166,  167,  171,  168,  171,  167,  172,  173,
+      172,  174,  179,  171,  175,  176,  175,  176,  180,  179,
+      174,  172,  181,  175,  174,  183,  182,  184,  176,  180,
+      182,  418,  183,  185,  185,  185,  181,  256,  184,  187,
+      187,  187,  191,  191,  191,  198,  192,  192,  192,  185,
+      193,  193,  193,  187,  192,  187,  196,  198,  191,  198,
+      200,  196,  192,  196,  252,  252,  193,  197,  197,  197,
+      199,  199,  199,  201,  265,  202,  200,  201,  200,  201,
+
+      202,  265,  203,  203,  291,  204,  202,  204,  202,  191,
+      203,  205,  205,  291,  205,  206,  206,  206,  207,  294,
+      207,  294,  207,  208,  208,  208,  209,  209,  210,  209,
+      251,  213,  211,  213,  251,  213,  210,  214,  210,  211,
+      211,  203,  211,  203,  212,  214,  212,  214,  215,  212,
+      216,  216,  216,  217,  217,  416,  215,  266,  215,  246,
+      246,  217,  218,  218,  218,  221,  221,  218,  266,  228,
+      230,  230,  230,  228,  228,  246,  218,  228,  218,  287,
+      287,  221,  221,  232,  232,  232,  230,  233,  233,  233,
+      234,  234,  234,  236,  236,  236,  415,  232,  234,  232,
+
+      258,  236,  414,  233,  246,  258,  234,  247,  247,  236,
+      221,  237,  237,  237,  239,  239,  239,  269,  413,  240,
+      240,  318,  318,  247,  269,  244,  244,  240,  239,  261,
+      239,  240,  240,  244,  233,  250,  250,  244,  244,  255,
+      255,  244,  263,  261,  412,  270,  274,  273,  300,  250,
+      300,  250,  263,  255,  273,  255,  270,  274,  263,  275,
+      276,  277,  278,  276,  280,  275,  281,  280,  277,  275,
+      279,  400,  290,  278,  261,  281,  279,  275,  324,  281,
+      279,  276,  285,  290,  255,  280,  324,  283,  279,  283,
+      284,  285,  284,  288,  288,  285,  283,  293,  293,  293,
+
+      295,  295,  295,  284,  297,  296,  398,  288,  296,  298,
+      296,  299,  302,  293,  301,  301,  301,  303,  390,  387,
+      297,  298,  297,  298,  309,  299,  309,  299,  302,  303,
+      302,  303,  304,  304,  304,  305,  305,  305,  307,  310,
+      304,  310,  308,  305,  293,  308,  385,  308,  304,  314,
+      307,  305,  307,  311,  311,  311,  312,  313,  312,  355,
+      313,  314,  313,  314,  315,  316,  384,  315,  355,  315,
+      383,  316,  355,  316,  317,  317,  319,  319,  321,  321,
+      321,  382,  317,  325,  319,  322,  322,  322,  323,  323,
+      323,  325,  330,  322,  321,  342,  344,  341,  342,  344,
+
+      346,  322,  330,  341,  364,  381,  346,  341,  330,  347,
+      346,  349,  347,  364,  349,  341,  342,  344,  346,  361,
+      361,  362,  362,  363,  369,  321,  369,  365,  366,  359,
+      347,  367,  349,  361,  368,  362,  365,  366,  367,  370,
+      367,  375,  371,  368,  371,  368,  376,  370,  357,  370,
+      372,  372,  372,  374,  374,  375,  374,  375,  378,  377,
+      376,  377,  376,  377,  379,  380,  388,  394,  379,  393,
+      379,  378,  393,  378,  356,  396,  402,  380,  396,  380,
+      388,  394,  403,  402,  404,  404,  407,  406,  405,  353,
+      393,  403,  405,  406,  405,  406,  396,  408,  407,  410,
+
+      407,  408,  411,  408,  409,  409,  409,  417,  410,  424,
+      410,  424,  419,  351,  411,  339,  411,  423,  423,  423,
+      337,  417,  334,  404,  433,  404,  419,  422,  422,  422,
+      425,  425,  425,  423,  426,  422,  433,  440,  433,  463,
+      442,  440,  463,  422,  442,  426,  464,  426,  465,  464,
+      332,  465,  329,  328,  327,  440,  326,  320,  442,  445,
+      445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
+      445,  445,  445,  445,  445,  446,  446,  446,  446,  446,
+      446,  446,  446,  446,  446,  446,  446,  446,  446,  446,
+      446,  447,  447,  447,  447,  447,  447,  447,  447,  447,
+
+      447,  447,  447,  447,  447,  447,  447,  448,  448,  448,
+      448,  448,  448,  448,  448,  448,  448,  448,  448,  448,
+      448,  448,  448,  449,  449,  449,  449,  449,  449,  449,
+      449,  449,  449,  449,  449,  449,  449,  449,  449,  450,
+      450,  450,  450,  450,  450,  450,  450,  450,  450,  450,
+      450,  450,  450,  450,  450,  451,  451,  451,  451,  286,
+      451,  451,  451,  451,  451,  451,  451,  451,  451,  282,
+      451,  452,  452,  272,  452,  452,  452,  452,  452,  452,
+      452,  452,  452,  452,  452,  452,  452,  453,  453,  268,
+      453,  453,  453,  260,  453,  453,  259,  453,  453,  453,
+
+      453,  453,  453,  454,  454,  454,  454,  454,  454,  454,
+      454,  454,  454,  454,  454,  454,  454,  454,  454,  455,
+      455,  254,  455,  455,  455,  249,  455,  455,  455,  455,
+      455,  455,  455,  455,  455,  456,  456,  242,  456,  456,
+      456,  456,  456,  456,  456,  456,  456,  456,  456,  456,
+      456,  457,  457,  457,  231,  457,  226,  220,  219,  190,
+      457,  457,  188,  457,  458,  458,  458,  186,  169,  164,
+      136,  129,  115,  104,   84,   83,  458,  459,   81,  459,
+      459,   71,  459,  459,   64,  459,  460,  460,  460,   62,
+      460,   58,   52,   33,    0,  460,  460,    0,  460,  461,
+
+      461,  461,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,  461,  462,  462,    0,    0,  462,    0,  462,  462,
+        0,  462,  462,    0,  462,  466,    0,    0,    0,  466,
+      466,  466,    0,  466,  466,  467,  467,  467,    0,    0,
+        0,    0,    0,    0,    0,  467,    0,  467,    0,  467,
+      468,  468,    0,    0,  468,    0,    0,    0,    0,  468,
+        0,    0,  468,  469,  469,    0,  469,  470,  470,  470,
+        0,    0,    0,    0,    0,    0,    0,  470,    0,  470,
+        0,  470,  471,    0,    0,    0,  471,    0,    0,    0,
+        0,  471,    0,    0,  471,  472,    0,  472,    0,    0,
+
+      472,  473,  473,  473,  473,  473,  473,    0,  473,  473,
+        0,  473,  473,  473,  473,  473,  473,  474,  474,  474,
+      474,  474,  474,  474,  474,  474,  474,  474,  474,  474,
+      474,  474,  474,  475,  475,  475,  475,  475,  475,    0,
+      475,  475,    0,  475,  475,  475,  475,  475,  475,  476,
+      476,  476,  476,  476,  476,  476,  476,  476,  476,  476,
+      476,  476,  476,  476,  476,  477,  477,  477,  477,  477,
+      477,  477,  477,  477,  477,  477,  477,  477,  477,  477,
+      477,  478,  478,  478,  478,  478,  478,  478,  478,  478,
+      478,  478,  478,  478,  478,  478,  478,  479,  479,  479,
+
+      479,  479,  479,  479,  479,  479,  479,  479,  479,  479,
+      479,  479,  479,  480,  480,  480,  480,  480,  480,  480,
+      480,  480,  480,  480,  480,  480,  480,  480,  480,  481,
+      481,  481,  481,  481,  481,  481,  481,  481,  481,  481,
+      481,  481,  481,  481,  481,  482,  482,  482,  482,  482,
+      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
+      482,  483,  483,  483,  483,  483,  483,  483,  483,  483,
+      483,  483,  483,  483,  483,  483,  483,  484,  484,  484,
+      484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
+      484,  484,  484,  485,  485,  485,  485,  485,  485,  485,
+
+      485,  485,  485,  485,  485,  485,  485,  485,  485,  486,
+      486,  486,  486,  486,  486,  486,  486,  486,  486,  486,
+      486,  486,  486,  486,  486,  487,  487,  487,  487,  487,
+      487,    0,  487,  487,    0,  487,  487,  487,  487,  487,
+      487,  488,  488,  488,  488,  488,  488,  488,  488,  488,
+      488,  488,  488,  488,  488,  488,  488,  489,  489,  489,
+      489,  489,  489,    0,  489,  489,    0,  489,  489,  489,
+      489,  489,  489,  490,  490,  490,  490,  490,  490,  490,
+      490,  490,  490,  490,  490,  490,  490,  490,  490,  491,
+      491,  491,  491,  491,  491,  491,  491,  491,  491,  491,
+
+      491,  491,  491,  491,  491,  492,  492,  492,  492,  492,
+      492,  492,  492,  492,  492,  492,  492,  492,  492,  492,
+      492,  493,  493,  493,  493,  493,  493,  493,  493,  493,
+      493,  493,  493,  493,  493,  493,  493,  494,  494,  494,
+      494,  494,  494,  494,  494,  494,  494,  494,  494,  494,
+      494,  494,  494,  495,  495,  495,  495,  495,  495,  495,
+      495,  495,  495,  495,  495,  495,  495,  495,  495,  496,
+      496,  496,  496,  496,  496,  496,  496,  496,  496,  496,
+      496,  496,  496,  496,  496,  497,  497,  497,  497,  497,
+      497,  497,  497,  497,  497,  497,  497,  497,  497,  497,
+
+      497,  498,  498,  498,  498,  498,  498,    0,  498,  498,
+        0,  498,  498,  498,  498,  498,  498,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444,  444,  444,  444,
+      444,  444,  444,  444,  444,  444,  444
+    } ;
+
+static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
+static char *yy_full_match;
+static int yy_lp;
+static int yy_looking_for_trail_begin = 0;
+static int yy_full_lp;
+static int *yy_full_state;
+#define YY_TRAILING_MASK 0x2000
+#define YY_TRAILING_HEAD_MASK 0x4000
+#define REJECT \
+{ \
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
+yy_cp = yy_full_match; /* restore poss. backed-over text */ \
+yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
+yy_state_ptr = yy_full_state; /* restore orig. state */ \
+yy_current_state = *yy_state_ptr; /* restore curr. state */ \
+++yy_lp; \
+goto find_rule; \
+}
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "code.l"
+#define INITIAL 0
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+#line 18 "code.l"
+
+/*
+ *	includes
+ */
+#include <stdio.h>
+#include <iostream.h>
+#include <assert.h>
+#include <ctype.h>
+#include <qregexp.h>
+
+#include "qtbc.h"
+#include "scanner.h"
+#include "entry.h"
+#include "doxygen.h"
+#include "message.h"
+#include "outputlist.h"
+#include "util.h"
+
+#define YY_NO_UNPUT
+#define YY_NEVER_INTERACTIVE 1
+  
+class CodeClassDef 
+{
+  public:
+    CodeClassDef() {}
+    CodeClassDef(const CodeClassDef &d)
+    {
+      name = d.name;
+      bases = d.bases;
+    }
+   ~CodeClassDef() {}
+
+    QCString name;
+    QStrList bases;
+};  
+  
+class CodeVarDef
+{
+  public:
+    CodeVarDef() {}
+    CodeVarDef(const CodeVarDef &d) 
+    { 
+      name = d.name; 
+      type = d.type; 
+      classScope = d.classScope;  
+    }
+   ~CodeVarDef() {} 
+    
+    QCString name;
+    QCString type; 
+    QCString classScope;
+};
+
+typedef QList<CodeClassDef> CodeClassList; 
+typedef QDict<CodeClassDef> CodeClassDict;
+typedef QList<CodeVarDef>   CodeVarList; 
+
+static CodeClassList codeClassList;
+static CodeClassDict codeClassDict(17);
+static CodeVarList codeVarList;
+static CodeVarList codeParmList;
+
+/* -----------------------------------------------------------------
+ *
+ *	statics
+ */
+  
+static const char * inputString;     //!< the code fragment as text
+static int	    inputPosition;   //!< read offset during parsing 
+static int          inputLines;      //!< number of line in the code fragment
+static int	    yyLineNr;        //!< current line number
+static int	    lastCContext;
+static int	    lastSpecialCContext;
+static int          lastStringContext;
+static int	    bracketCount = 0;
+static int	    curlyCount   = 0;
+static int	    sharpCount   = 0;
+static QCString     type;
+static QCString     name;
+static QCString     args;
+static QCString     parmType;
+static QCString     parmName;
+static bool         inClass;
+static QCString     classScope;
+static OutputList   *code;
+static CodeClassDef ccd;
+static CodeVarDef   cvd;
+static bool         exampleBlock;
+static QCString     exampleName;
+static QCString     exampleFile;
+static int          anchorCount;
+static FileDef     *sourceFileDef;
+static QCString     lastVariable;
+
+static void addType()
+{
+  if (name=="const") { name.resize(0); return; }
+  if (type.length()) type += ' ' ;
+  type += name ;
+  name.resize(0) ;
+  if (type.length()) type += ' ' ;
+  type += args ;
+  args.resize(0) ;
+}
+
+static void addParmType()
+{
+  if (parmName=="const") { parmName.resize(0); return; }
+  if (parmType.length()) parmType += ' ' ;
+  parmType += parmName ;
+  parmName.resize(0) ;
+}
+
+static void setClassScope(const QCString &name)
+{
+  QCString n=name;
+  n=n.simplifyWhiteSpace();
+  int index;
+  if ((index=n.find("::"))!=-1)
+    classScope=n.left(index);
+  else
+    classScope.resize(0);
+  //printf("--->New class scope `%s'\n",classScope.data());
+}
+
+static void addVariable()
+{
+  cvd.name=name.copy().simplifyWhiteSpace();
+  cvd.type=type.copy().simplifyWhiteSpace();
+  if (type.length()==0) 
+    return;
+  else if ((getClass(cvd.type)) || (codeClassDict[cvd.type])) 
+  {
+    cvd.classScope=classScope;
+    codeVarList.append(new CodeVarDef(cvd)); // add it to a list
+  }
+}
+
+static void addParameter()
+{
+  cvd.name=parmName.copy().simplifyWhiteSpace();
+  cvd.type=parmType.copy().simplifyWhiteSpace();
+  if (cvd.type.length()==0) 
+    return;
+  else if ((getClass(cvd.type)) || (codeClassDict[cvd.type])) 
+  {
+    cvd.classScope=classScope;
+    codeParmList.append(new CodeVarDef(cvd)); // add it to a list
+  }
+}
+
+static void generateClassLink(OutputList &ol,const char *clName)
+{
+  QCString className=clName;
+  if (className.length()==0) return;
+  ClassDef *cd;
+  if ((cd=getClass(className)) && cd->isLinkable())
+  {
+    if (exampleBlock)
+    {
+      QCString anchor;
+      anchor.sprintf("_a%d",anchorCount);
+      //printf("addExampleClass(%s,%s,%s)\n",anchor.data(),exampleName.data(),
+      //                                   exampleFile.data());
+      if (cd->addExample(anchor,exampleName,exampleFile))
+      {
+	bool latexOn = ol.isEnabled(OutputGenerator::Latex);
+	if (latexOn) ol.disable(OutputGenerator::Latex);
+	ol.writeAnchor(anchor);
+	if (latexOn) ol.enable(OutputGenerator::Latex);
+	anchorCount++;
+      }
+    }
+    ol.writeCodeLink(cd->getReference(),cd->getOutputFileBase(),0,className);
+  }
+  else
+  {
+    ol.codify(clName);
+  }
+}
+
+static bool getLink(const char *className,
+                    const char *memberName,OutputList &result,
+		    const char *text=0)
+{
+  MemberDef    *md;
+  ClassDef     *cd;
+  FileDef      *fd;
+  NamespaceDef *nd;
+  QCString m=memberName;
+  QCString c=className;
+  //printf("Trying `%s'::`%s'\n",c.data(),m.data());
+  if (getDefs(c,m,"()",md,cd,fd,nd) && md->isLinkable())
+  {
+    //printf("Found!\n");
+    if (exampleBlock)
+    {
+      QCString anchor;
+      anchor.sprintf("a%d",anchorCount);
+      //printf("addExampleFile(%s,%s,%s)\n",anchor.data(),exampleName.data(),
+      //                                  exampleFile.data());
+      if (md->addExample(anchor,exampleName,exampleFile))
+      {
+	bool latexEnabled = result.isEnabled(OutputGenerator::Latex);
+	if (latexEnabled) result.disable(OutputGenerator::Latex);
+	result.writeAnchor(anchor);
+	if (latexEnabled) result.enable(OutputGenerator::Latex);
+	anchorCount++;
+      }
+    }
+    Definition *d=0;
+    if (cd) d=cd; else if (cd) d=nd; else d=fd;
+
+    if (d)
+    {
+      //printf("d->getOutputBase()=`%s' name=`%s'\n",d->getOutputFileBase().data(),md->name().data());
+      result.writeCodeLink(d->getReference(),d->getOutputFileBase(),
+	                   md->anchor(),text ? text : memberName);
+      return TRUE;
+    } 
+  }
+  return FALSE;
+}
+
+static ClassDef *stripClassName(const char *s)
+{
+  QCString tmp=s;
+  QRegExp re("[a-z_A-Z][a-z_A-Z0-9]*");
+  int p=0,i,l;
+  while ((i=re.match(tmp,p,&l))!=-1)
+  {
+    ClassDef *cd=getClass(tmp.mid(i,l));
+    if (cd) return cd;
+    p=i+l;
+  }
+  return 0;
+}
+
+static void generateMemberLink(OutputList &ol,const char *varName,
+            const char *memName)
+{
+  //printf("generateMemberLink(object=%s,mem=%s) classScope=%s\n",
+  //                          varName,memName,classScope.data());
+  CodeVarDef *cvd=codeParmList.last();
+  while (cvd && cvd->name!=varName) cvd=codeParmList.prev();
+  if (!cvd)
+  {
+    cvd=codeVarList.last();
+    while (cvd && cvd->name!=varName) cvd=codeVarList.prev();
+  }
+  if (cvd) // variable found
+  {
+    //printf("variable found type=%s!\n",cvd->type.data());
+    CodeClassDef *ccd=codeClassDict[cvd->type];
+    if (ccd)
+    {
+      //printf("Class found!\n");
+      OutputList result(&ol);
+      if (getLink(ccd->name,memName,result)) 
+      {
+        //printf("Found result!\n");
+        ol+=result;
+        return;
+      }
+      char *s=ccd->bases.first();
+      while (s)
+      {
+	OutputList result(&ol);
+	if (getLink(s,memName,result)) 
+	{
+	  //printf("Found result!\n");
+	  ol+=result;
+	  return;
+	}
+	s=ccd->bases.next();
+      }
+    }
+    else 
+    {
+      OutputList result(&ol);
+      if (getLink(cvd->type,memName,result))
+      {
+        ol+=result;
+      }
+      else
+      {
+	ol.codify(memName);
+      }
+      return;
+    }
+  }
+  else
+  {
+    ClassDef *vcd = getClass(classScope);
+    if (vcd)
+    {
+      //printf("Found class for variable `%s'\n",varName);
+      MemberName *vmn=memberNameDict[varName];
+      if (vmn)
+      {
+	MemberNameIterator vmni(*vmn);
+	MemberDef *vmd;
+	for (;(vmd=vmni.current());++vmni)
+	{
+	  if (vmd->isVariable() && vmd->memberClass()==vcd)
+	  {
+	    //printf("Found variable type=%s\n",vmd->typeString());
+	    ClassDef *mcd=stripClassName(vmd->typeString());
+	    if (mcd)
+	    {
+	      MemberName *mmn=memberNameDict[memName];
+	      if (mmn)
+	      {
+	      MemberNameIterator mmni(*mmn);
+	      MemberDef *mmd;
+	      for (;(mmd=mmni.current());++mmni)
+	      {
+		if (mmd->memberClass()==mcd)
+		{
+		  ol.writeCodeLink(mcd->getReference(),mcd->getOutputFileBase(),
+		      mmd->anchor(),memName);
+		  return;
+		}
+	      }
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  }
+  ol.codify(memName);
+  return;
+}
+
+static void generateFunctionLink(OutputList &ol,const char *funcName)
+{
+  OutputList result(&ol);
+  CodeClassDef *ccd=0;
+  QCString locScope=classScope.copy();
+  QCString locFunc=funcName;
+  int i=locFunc.findRev("::");
+  if (i>0)
+  {
+    locScope=locFunc.left(i);
+    locFunc=locFunc.right(locFunc.length()-i-2);
+  }
+  //printf("generateFunctionLink(%s) classScope=%s\n",locFunc.data(),locScope.data());
+  if (locScope.length()>0 && (ccd=codeClassDict[locScope]))
+  {
+    //printf("using classScope %s\n",classScope.data());
+    char *s=ccd->bases.first();
+    while (s)
+    {
+      if (getLink(s,locFunc,result,funcName)) 
+      {
+	ol+=result;
+	return;
+      }
+      s=ccd->bases.next();
+    }
+  }
+  if (getLink(locScope,locFunc,result,funcName))
+  {
+    ol+=result;
+  }
+  else
+  {
+    ol.codify(funcName);
+  }
+  return;
+}
+
+/*! counts the number of lines in the input */
+static int countLines()
+{
+  const char *p=inputString;
+  char c;
+  int count=1;
+  while ((c=*p++)) if (c=='\n') count++; 
+  return count;
+}
+
+static void startCodeLine()
+{
+  if (sourceFileDef)
+  {
+    QCString lineNumber,lineAnchor;
+    lineNumber.sprintf("%05d ",yyLineNr);
+    lineAnchor.sprintf("l%05d",yyLineNr);
+    //MemberDef *md = sourceFileDef->getSourceDefinition(yyLineNr);
+    //Definition *d=0;
+    //if (md)
+    //{
+    //  d=md->memberClass();
+    //  if (!d) d=md->getFileDef();
+    //}
+    //if (md && d)
+    Definition *d   = sourceFileDef->getSourceDefinition(yyLineNr);
+    QCString anchor = sourceFileDef->getSourceAnchor(yyLineNr);
+    if (d && d->isLinkableInProject())
+    {
+      code->startCodeAnchor(lineAnchor);
+      code->writeCodeLink(d->getReference(),d->getOutputFileBase(),
+	                   anchor,lineNumber);
+      code->endCodeAnchor();
+    }
+    else
+    {
+      code->codify(lineNumber);
+    }
+  }
+  code->startCodeLine(); 
+}
+
+static void codifyLines(char *text)
+{
+  char *p=text,*sp=p;
+  char c;
+  bool done=FALSE;
+  while (!done)
+  {
+    sp=p;
+    while ((c=*p++) && c!='\n');
+    if (c=='\n')
+    {
+      yyLineNr++;
+      *(p-1)='\0';
+      code->codify(sp);
+      code->endCodeLine();
+      if (yyLineNr<inputLines) 
+      {
+	startCodeLine();
+      }
+    }
+    else
+    {
+      code->codify(sp);
+      done=TRUE;
+    }
+  }
+}
+
+/* -----------------------------------------------------------------
+ */
+#undef	YY_INPUT
+#define	YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
+
+static int yyread(char *buf,int max_size)
+{
+    int c=0;
+    while( c < max_size && inputString[inputPosition] )
+    {
+	*buf = inputString[inputPosition++] ;
+	c++; buf++;
+    }
+    return c;
+}
+
+#define SkipString 1
+
+#define SkipCPP 2
+
+#define SkipComment 3
+
+#define SkipCxxComment 4
+
+#define RemoveSpecialCComment 5
+
+#define StripSpecialCComment 6
+
+#define Body 7
+
+#define FuncCall 8
+
+#define MemberCall 9
+
+#define MemberCall2 10
+
+#define SkipInits 11
+
+#define ClassName 12
+
+#define Bases 13
+
+#define SkipSharp 14
+
+#define ReadInclude 15
+
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( 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->yy_is_interactive ) \
+		{ \
+		int c = '*', 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 if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+		  && ferror( yyin ) ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* 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 \
+	if ( yyleng > 0 ) \
+		yy_current_buffer->yy_at_bol = \
+				(yytext[yyleng - 1] == '\n'); \
+	YY_USER_ACTION
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+
+#line 502 "code.l"
+
+
+
+	if ( yy_init )
+		{
+		yy_init = 0;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! yy_current_buffer )
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+
+		yy_load_buffer_state();
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yy_start;
+		yy_current_state += YY_AT_BOL();
+		yy_state_ptr = yy_state_buf;
+		*yy_state_ptr++ = yy_current_state;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*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 >= 445 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			*yy_state_ptr++ = yy_current_state;
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 2018 );
+
+yy_find_action:
+		yy_current_state = *--yy_state_ptr;
+		yy_lp = yy_accept[yy_current_state];
+find_rule: /* we branch to this label when backing up */
+		for ( ; ; ) /* until we find what rule we matched */
+			{
+			if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
+				{
+				yy_act = yy_acclist[yy_lp];
+				if ( yy_act & YY_TRAILING_HEAD_MASK ||
+				     yy_looking_for_trail_begin )
+					{
+					if ( yy_act == yy_looking_for_trail_begin )
+						{
+						yy_looking_for_trail_begin = 0;
+						yy_act &= ~YY_TRAILING_HEAD_MASK;
+						break;
+						}
+					}
+				else if ( yy_act & YY_TRAILING_MASK )
+					{
+					yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
+					yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
+					}
+				else
+					{
+					yy_full_match = yy_cp;
+					yy_full_state = yy_state_ptr;
+					yy_full_lp = yy_lp;
+					break;
+					}
+				++yy_lp;
+				goto find_rule;
+				}
+			--yy_cp;
+			yy_current_state = *--yy_state_ptr;
+			yy_lp = 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 1:
+YY_RULE_SETUP
+#line 504 "code.l"
+
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 505 "code.l"
+{
+					  code->codify(yytext);
+  					  BEGIN( ReadInclude ); 
+					}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 509 "code.l"
+{ 
+                                          codifyLines(yytext);
+					  //code->codify(yytext);
+  					  BEGIN( ClassName ); 
+					}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 514 "code.l"
+{
+					  //FileInfo *f;
+					  bool ambig;
+                                          FileDef *fd;
+					  if ((fd=findFileDef(&inputNameDict,yytext,ambig)) &&
+					      fd->isLinkable())
+					  {
+					    code->writeCodeLink(fd->getReference(),fd->getOutputFileBase(),0,yytext);
+					  }
+					  else
+					  {
+					    code->codify(yytext);
+					  }
+					  char c=yyinput();
+					  QCString text;
+					  text+=c;
+					  code->codify(text);
+					  BEGIN( Body );
+  					}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 533 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  BEGIN( SkipCPP ) ; 
+					}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 537 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 540 "code.l"
+{ 
+  					  codifyLines(yytext);
+					}
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 543 "code.l"
+{ 
+  					  codifyLines(yytext);
+					  BEGIN( Body ) ;
+					}
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 547 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 550 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  curlyCount++;
+  					  type.resize(0); name.resize(0);
+					}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 555 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  inClass=FALSE; 
+					  if (--curlyCount<=0) 
+					  {
+					    classScope.resize(0);
+					    codeParmList.clear();
+					  }
+					}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 564 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  BEGIN( Body ); 
+					}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 568 "code.l"
+{
+					  addType();
+					  code->codify(yytext);
+					}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 572 "code.l"
+{
+					  ccd.name=yytext;
+					  addType();
+					  generateClassLink(*code,yytext);
+					}
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 577 "code.l"
+{
+  					  codifyLines(yytext);
+  					  BEGIN( Bases ); 
+					}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 581 "code.l"
+{
+  					  code->codify(yytext);
+					  curlyCount++;
+					  inClass=TRUE;
+					  if (ccd.name.length()>0)
+					  {
+					    classScope=ccd.name.copy();
+					    CodeClassDef *cd=new CodeClassDef(ccd);
+					    codeClassList.append(cd);
+					    codeClassDict.insert(cd->name,cd);
+					  }
+					  BEGIN( Body );
+ 					}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 594 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 597 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 600 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 603 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 606 "code.l"
+{ 
+					  //printf("%s:addBase(%s)\n",ccd.name.data(),yytext);
+  					  ccd.bases.inSort(yytext); 
+					  generateClassLink(*code,yytext);
+					}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 611 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  sharpCount=1;
+					  BEGIN ( SkipSharp );
+					}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 616 "code.l"
+{
+  					  code->codify(yytext);
+  					  ++sharpCount; 
+					}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 620 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  if (--sharpCount<=0)
+					  BEGIN ( Bases );
+					}
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 625 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 26:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 630 "code.l"
+{
+  					  codifyLines(yytext);
+  				          name.resize(0);type.resize(0);
+  					}
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 634 "code.l"
+{
+  					  codifyLines(yytext);
+  				          name.resize(0);type.resize(0);
+  					}
+	YY_BREAK
+/*
+<Body>([a-z_A-Z~][a-z_A-Z0-9]*)/([ \t]*)	{ 
+					  generateClassLink(*code,yytext);
+					  addType();
+  					  name+=yytext; 
+					}
+  */
+case 28:
+YY_RULE_SETUP
+#line 645 "code.l"
+{ 
+					  generateClassLink(*code,yytext);
+  					  //codifyLines(yytext);
+					  addType();
+  					  name+=yytext; 
+					}
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 651 "code.l"
+{
+  					  addType();
+					  //if (type.length()==0)
+					  QCString tmp=yytext;
+					  generateFunctionLink(*code,yytext);
+					  //else
+  					  //  code->codify(yytext);
+  					  bracketCount=1;
+					  args.resize(0);
+  					  name+=yytext; 
+  					  BEGIN( FuncCall );
+					}
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 663 "code.l"
+{
+  					  code->codify(yytext);
+  					  lastStringContext=YY_START;
+  					  BEGIN( SkipString );
+  					}
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 668 "code.l"
+{ 
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 671 "code.l"
+{
+  					  code->codify(yytext);
+  					}
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 674 "code.l"
+{
+  					  code->codify(yytext);
+  					  BEGIN( lastStringContext );
+  					}
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 678 "code.l"
+{
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 681 "code.l"
+{
+  					  code->codify(yytext);
+  					  name.resize(0);type.resize(0);
+  					}
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 685 "code.l"
+{
+  					  code->codify(yytext);
+  					}
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 688 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  BEGIN( MemberCall ); 
+					}
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 692 "code.l"
+{
+  					  if (name.length()>0)
+					    generateMemberLink(*code,name,yytext);
+					  else
+  					    code->codify(yytext);
+  					  name.resize(0);type.resize(0);
+					  bracketCount=0;
+					  BEGIN(FuncCall);
+  					}
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 701 "code.l"
+{ 
+  					  code->codify(yytext);
+    					  type.resize(0);
+					  name.resize(0);
+					  BEGIN(Body); 
+					}
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 707 "code.l"
+{
+  					  code->codify(yytext);
+  					  if (type.length()>0) 
+					    addVariable();
+					  name.resize(0);
+					  if (*yytext!=',') type.resize(0);
+					  args.resize(0);
+  					}
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 715 "code.l"
+{
+					  code->codify(yytext);
+					}
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 718 "code.l"
+{
+					  addParmType();
+					  parmName=yytext; 
+					  generateClassLink(*code,yytext);
+					}
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 723 "code.l"
+{
+  					  code->codify(yytext);
+					  addParameter();
+					  parmType.resize(0);parmName.resize(0);
+					}
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 728 "code.l"
+{
+  					  code->codify(yytext);
+  					  bracketCount++; 
+					}
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 732 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  if (--bracketCount<=0) 
+					  name.resize(0);args.resize(0);
+					  parmType.resize(0);parmName.resize(0);
+  					  BEGIN( Body ); 
+					}
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 739 "code.l"
+{
+  					  codifyLines(yytext);
+  					  bracketCount=0;
+					  if (!inClass && type.length()>0)
+					    addVariable();
+					  name.resize(0);type.resize(0);
+					  parmType.resize(0);parmName.resize(0);
+  					  BEGIN( Body );
+  					}
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 748 "code.l"
+{
+					  addParameter();
+					  parmType.resize(0);parmName.resize(0);
+					  if (name.length()>0) setClassScope(name);
+  					  codifyLines(yytext);
+					  curlyCount++;
+  					  type.resize(0); name.resize(0);
+					  BEGIN( Body );
+  					}
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 757 "code.l"
+{
+					  addParameter();
+					  parmType.resize(0);parmName.resize(0);
+					  if (name.length()>0) setClassScope(name);
+  					  codifyLines(yytext);
+  					  type.resize(0); name.resize(0);
+					  BEGIN( SkipInits );
+  					}
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 765 "code.l"
+{ 
+  					  code->codify(yytext);
+					  curlyCount++; 
+					  BEGIN( Body ); 
+					}
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 770 "code.l"
+{
+					  generateClassLink(*code,yytext);
+  					}
+	YY_BREAK
+case 51:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 773 "code.l"
+{
+					  generateFunctionLink(*code,yytext);
+					}
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 776 "code.l"
+{ 
+  					  code->codify(yytext);
+					  args=yytext; 
+					  BEGIN( MemberCall2 ); 
+					}
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 781 "code.l"
+{ 
+  					  if (args.length()>0)
+					    generateMemberLink(*code,args,yytext);
+					  else
+  					    code->codify(yytext);
+					  args.resize(0);
+					  BEGIN( FuncCall );
+					}
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+#line 789 "code.l"
+{
+  					  code->codify(yytext);
+    					  args=yytext;
+    					}
+	YY_BREAK
+case 55:
+YY_RULE_SETUP
+#line 793 "code.l"
+{
+  					  code->codify(yytext);
+  					}
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+#line 796 "code.l"
+{
+  					  code->codify(yytext);
+  					}
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+#line 799 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  BEGIN( lastCContext ) ; 
+					}
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+#line 803 "code.l"
+{ 
+  					  codifyLines(yytext);
+					  BEGIN( lastCContext ) ;
+					}
+	YY_BREAK
+case 59:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 807 "code.l"
+{
+  					  yyLineNr+=QCString(yytext).contains('\n');
+					}
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 810 "code.l"
+{
+  					  yyLineNr+=QCString(yytext).contains('\n');
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					  BEGIN(lastSpecialCContext);
+  					}
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+#line 819 "code.l"
+{
+  					  BEGIN(lastSpecialCContext);
+  					}
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 822 "code.l"
+
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 823 "code.l"
+
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 824 "code.l"
+{ yyLineNr++; }
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 825 "code.l"
+
+	YY_BREAK
+/*
+<SkipSpecialComment>"//"
+<SkipSpecialComment>[ \t]*"* /"		{
+  					  BEGIN( lastDContext ) ;
+  					}
+<SkipSpecialComment>[ \t]*"* /"[ \t\n]*"\n"/"/ *"  {
+  					  //code->codify("\n");
+					  //QCString lineText=yytext;
+  					  //yyLineNr+=lineText.contains('\n');
+  					  BEGIN( lastDContext ) ;
+  					}
+<SkipSpecialComment>.	
+<SkipSpecialComment>\n			{ 
+  					  codifyLines(yytext); 
+					}
+<SkipSpecialCxxComment>.* /\n		{
+  					  codifyLines(yytext); 
+					  BEGIN( lastDContext ) ;
+  					}
+<SkipSpecialCxxComment>.	
+<SkipSpecialCxxComment>\n		{ 
+  					  codifyLines(yytext); 
+					}
+ */
+case 66:
+YY_RULE_SETUP
+#line 850 "code.l"
+{ // remove special one-line comment
+  					  yyLineNr+=((QCString)yytext).contains('\n');
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					}
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 858 "code.l"
+{ // remove special one-line comment
+  					  yyLineNr++;
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					}
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 866 "code.l"
+{ // strip special one-line comment
+  					  char c[2]; c[0]='\n'; c[1]=0;
+  					  codifyLines(c);
+  					}
+	YY_BREAK
+case 69:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 870 "code.l"
+{
+					  lastSpecialCContext = YY_START;
+					  yyLineNr++;
+					  BEGIN(RemoveSpecialCComment);
+					}
+	YY_BREAK
+case 70:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 875 "code.l"
+{ // special C comment block at a new line
+					  lastSpecialCContext = YY_START;
+					  BEGIN(RemoveSpecialCComment);
+					}
+	YY_BREAK
+case 71:
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
+yy_c_buf_p = yy_cp = yy_bp + 3;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 879 "code.l"
+{ // special C comment block half way a line
+					  lastSpecialCContext = YY_START;
+					  BEGIN(RemoveSpecialCComment);
+					}
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
+#line 883 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  lastCContext = YY_START ;
+					  BEGIN( SkipComment ) ;
+					}
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+#line 888 "code.l"
+{ 
+  					  code->codify(yytext);
+  					  lastCContext = YY_START ;
+					  BEGIN( SkipCxxComment ) ;
+					}
+	YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 893 "code.l"
+{
+  					  codifyLines(yytext); 
+  					}
+	YY_BREAK
+case 75:
+YY_RULE_SETUP
+#line 896 "code.l"
+{
+  					  code->codify(yytext);
+					}
+	YY_BREAK
+/*
+<*>([ \t\n]*"\n"){2,}			{ // combine multiple blank lines
+  					  //QCString sepLine=yytext;
+  					  //code->codify("\n\n");
+  					  //yyLineNr+=sepLine.contains('\n'); 
+  					  //char sepLine[3]="\n\n";
+  					  codifyLines(yytext);
+					}
+  */
+case 76:
+YY_RULE_SETUP
+#line 909 "code.l"
+ECHO;
+	YY_BREAK
+			case YY_STATE_EOF(INITIAL):
+			case YY_STATE_EOF(SkipString):
+			case YY_STATE_EOF(SkipCPP):
+			case YY_STATE_EOF(SkipComment):
+			case YY_STATE_EOF(SkipCxxComment):
+			case YY_STATE_EOF(RemoveSpecialCComment):
+			case YY_STATE_EOF(StripSpecialCComment):
+			case YY_STATE_EOF(Body):
+			case YY_STATE_EOF(FuncCall):
+			case YY_STATE_EOF(MemberCall):
+			case YY_STATE_EOF(MemberCall2):
+			case YY_STATE_EOF(SkipInits):
+			case YY_STATE_EOF(ClassName):
+			case YY_STATE_EOF(Bases):
+			case YY_STATE_EOF(SkipSharp):
+			case YY_STATE_EOF(ReadInclude):
+				yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( yy_current_buffer->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.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap() )
+					{
+					/* 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.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of 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()
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr;
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( yy_current_buffer->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->yy_n_chars = yy_n_chars = 0;
+
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
+
+			int yy_c_buf_p_offset =
+				(int) (yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yy_flex_realloc( (void *) b->yy_ch_buf,
+							 b->yy_buf_size + 2 );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
+#endif
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yytext_ptr = &yy_current_buffer->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()
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+
+	yy_current_state = yy_start;
+	yy_current_state += YY_AT_BOL();
+	yy_state_ptr = yy_state_buf;
+	*yy_state_ptr++ = yy_current_state;
+
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		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 >= 445 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		*yy_state_ptr++ = yy_current_state;
+		}
+
+	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 );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+	{
+	register int yy_is_jam;
+
+	register YY_CHAR yy_c = 1;
+	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 >= 445 )
+			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 == 444);
+	if ( ! yy_is_jam )
+		*yy_state_ptr++ = yy_current_state;
+
+	return yy_is_jam ? 0 : yy_current_state;
+	}
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+	{
+	register char *yy_cp = yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
+
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		yy_current_buffer->yy_n_chars =
+			yy_n_chars = yy_current_buffer->yy_buf_size;
+
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+
+	yytext_ptr = yy_bp;
+	yy_hold_char = *yy_cp;
+	yy_c_buf_p = yy_cp;
+	}
+#endif	/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+	{
+	int c;
+
+	*yy_c_buf_p = yy_hold_char;
+
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			int offset = yy_c_buf_p - yytext_ptr;
+			++yy_c_buf_p;
+
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					yyrestart( yyin );
+
+					/* fall through */
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						return EOF;
+
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
+
+	yy_current_buffer->yy_at_bol = (c == '\n');
+
+	return c;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
+
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
+
+	/* 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.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+	{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	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 *) yy_flex_alloc( b->yy_buf_size + 2 );
+	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 );
+
+	return b;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+	{
+	if ( ! b )
+		return;
+
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yy_flex_free( (void *) b->yy_ch_buf );
+
+	yy_flex_free( (void *) b );
+	}
+
+
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+	{
+	yy_flush_buffer( b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+	b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+	b->yy_is_interactive = 0;
+#else
+	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+#endif
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+	{
+	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();
+	}
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+	{
+	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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	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 );
+
+	return b;
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+	{
+	int len;
+	for ( len = 0; yy_str[len]; ++len )
+		;
+
+	return yy_scan_bytes( yy_str, len );
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+	{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = len + 2;
+	buf = (char *) yy_flex_alloc( n );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < len; ++i )
+		buf[i] = bytes[i];
+
+	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n );
+	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;
+	}
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		yy_size_t new_size;
+
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
+
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
+
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
+
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+	}
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+	{
+	(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. */ \
+		yytext[yyleng] = yy_hold_char; \
+		yy_c_buf_p = yytext + n; \
+		yy_hold_char = *yy_c_buf_p; \
+		*yy_c_buf_p = '\0'; \
+		yyleng = n; \
+		} \
+	while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+	{
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+	}
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+	{
+	return (void *) malloc( size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+	{
+	/* 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 );
+	}
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+	{
+	free( ptr );
+	}
+
+#if YY_MAIN
+int main()
+	{
+	yylex();
+	return 0;
+	}
+#endif
+#line 909 "code.l"
+
+
+/*@ ----------------------------------------------------------------------------
+ */
+
+void initParseCodeContext()
+{
+  codeClassList.setAutoDelete(TRUE);
+  codeVarList.setAutoDelete(TRUE);
+  codeParmList.setAutoDelete(TRUE);
+  codeClassDict.clear();
+  codeClassList.clear();
+  codeVarList.clear();
+  codeParmList.clear();
+  ccd.bases.clear();
+  anchorCount = 0;
+}
+
+void parseCode(OutputList &ol,const char *className,const QCString &s, 
+                  bool exBlock, const char *exName,FileDef *fd)
+{
+  code = new OutputList(&ol);
+  if (s.length()==0) return;
+  inputString   = s;
+  inputPosition = 0;
+  inputLines    = countLines();
+  yyLineNr      = 1;
+  curlyCount    = 0;
+  bracketCount  = 0;
+  sharpCount    = 0;
+  classScope    = className;
+  exampleBlock  = exBlock; 
+  exampleName   = exName;
+  sourceFileDef = fd;
+  exampleFile   = convertSlashes(exampleName,TRUE)+"-example";
+  startCodeLine();
+  type.resize(0);
+  name.resize(0);
+  args.resize(0);
+  parmName.resize(0);
+  parmType.resize(0);
+  codeYYrestart( codeYYin );
+  BEGIN( Body );
+  codeYYlex();
+  //if (yyLineNr<=inputLines) code->endCodeLine();
+  ol+=*code;
+  delete code;
+  return;
+}
+
+extern "C" { // some bogus code to keep the compiler happy
+//  int  codeYYwrap() { return 1 ; }
+  void codeYYdummy() { yy_flex_realloc(0,0); } 
+}
diff --git a/src/code.h b/src/code.h
index bf67df6..78257be 100644
--- a/src/code.h
+++ b/src/code.h
@@ -21,8 +21,9 @@
 #include <stdio.h>
 
 class OutputList;
+class FileDef;
 
 extern void parseCode(OutputList &,const char *,const QCString &, 
-            bool ,const char *);
+            bool ,const char *,FileDef *fd=0);
 extern void initParseCodeContext();
 #endif
diff --git a/src/code.l b/src/code.l
index 2a60f6c..7536a0e 100644
--- a/src/code.l
+++ b/src/code.l
@@ -23,6 +23,7 @@
 #include <iostream.h>
 #include <assert.h>
 #include <ctype.h>
+#include <qregexp.h>
 
 #include "qtbc.h"
 #include "scanner.h"
@@ -69,7 +70,7 @@ class CodeVarDef
 
 typedef QList<CodeClassDef> CodeClassList; 
 typedef QDict<CodeClassDef> CodeClassDict;
-typedef QList<CodeVarDef> CodeVarList; 
+typedef QList<CodeVarDef>   CodeVarList; 
 
 static CodeClassList codeClassList;
 static CodeClassDict codeClassDict(17);
@@ -81,29 +82,32 @@ static CodeVarList codeParmList;
  *	statics
  */
   
-static const char * inputString;
-static int	    inputPosition;
+static const char * inputString;     //!< the code fragment as text
+static int	    inputPosition;   //!< read offset during parsing 
+static int          inputLines;      //!< number of line in the code fragment
+static int	    yyLineNr;        //!< current line number
 static int	    lastCContext;
-static int	    lastDContext;
+static int	    lastSpecialCContext;
 static int          lastStringContext;
 static int	    bracketCount = 0;
 static int	    curlyCount   = 0;
 static int	    sharpCount   = 0;
-static int	    yyLineNr     = 0;
-static QCString      type;
-static QCString      name;
-static QCString      args;
-static QCString      parmType;
-static QCString      parmName;
+static QCString     type;
+static QCString     name;
+static QCString     args;
+static QCString     parmType;
+static QCString     parmName;
 static bool         inClass;
-static QCString      classScope;
+static QCString     classScope;
 static OutputList   *code;
 static CodeClassDef ccd;
 static CodeVarDef   cvd;
 static bool         exampleBlock;
-static QCString      exampleName;
-static QCString      exampleFile;
+static QCString     exampleName;
+static QCString     exampleFile;
 static int          anchorCount;
+static FileDef     *sourceFileDef;
+static QCString     lastVariable;
 
 static void addType()
 {
@@ -193,7 +197,8 @@ static void generateClassLink(OutputList &ol,const char *clName)
 }
 
 static bool getLink(const char *className,
-                    const char *memberName,OutputList &result)
+                    const char *memberName,OutputList &result,
+		    const char *text=0)
 {
   MemberDef    *md;
   ClassDef     *cd;
@@ -227,34 +232,27 @@ static bool getLink(const char *className,
     {
       //printf("d->getOutputBase()=`%s' name=`%s'\n",d->getOutputFileBase().data(),md->name().data());
       result.writeCodeLink(d->getReference(),d->getOutputFileBase(),
-	                   md->anchor(),memberName);
+	                   md->anchor(),text ? text : memberName);
       return TRUE;
-
     } 
-
-//    if (cd)
-//    {
-//      result.writeCodeLink(cd->getReference(),cd->getOutputFileBase(),
-//	                        md->anchor(),memberName);
-//      return TRUE;
-//    }
-//    else if (nd)
-//    {
-//      result.writeCodeLink(nd->getReference(),nd->getOutputFileBase(),
-//	                        md->anchor(),memberName);
-//      return TRUE;
-//    }
-//    else if (fd)
-//    {
-//      result.writeCodeLink(fd->getReference(),fd->getOutputFileBase(),
-//	                        md->anchor(),memberName);
-//      return TRUE;
-//    }
   }
-  
   return FALSE;
 }
 
+static ClassDef *stripClassName(const char *s)
+{
+  QCString tmp=s;
+  QRegExp re("[a-z_A-Z][a-z_A-Z0-9]*");
+  int p=0,i,l;
+  while ((i=re.match(tmp,p,&l))!=-1)
+  {
+    ClassDef *cd=getClass(tmp.mid(i,l));
+    if (cd) return cd;
+    p=i+l;
+  }
+  return 0;
+}
+
 static void generateMemberLink(OutputList &ol,const char *varName,
             const char *memName)
 {
@@ -269,15 +267,25 @@ static void generateMemberLink(OutputList &ol,const char *varName,
   }
   if (cvd) // variable found
   {
+    //printf("variable found type=%s!\n",cvd->type.data());
     CodeClassDef *ccd=codeClassDict[cvd->type];
     if (ccd)
     {
+      //printf("Class found!\n");
+      OutputList result(&ol);
+      if (getLink(ccd->name,memName,result)) 
+      {
+        //printf("Found result!\n");
+        ol+=result;
+        return;
+      }
       char *s=ccd->bases.first();
       while (s)
       {
 	OutputList result(&ol);
 	if (getLink(s,memName,result)) 
 	{
+	  //printf("Found result!\n");
 	  ol+=result;
 	  return;
 	}
@@ -298,22 +306,70 @@ static void generateMemberLink(OutputList &ol,const char *varName,
       return;
     }
   }
+  else
+  {
+    ClassDef *vcd = getClass(classScope);
+    if (vcd)
+    {
+      //printf("Found class for variable `%s'\n",varName);
+      MemberName *vmn=memberNameDict[varName];
+      if (vmn)
+      {
+	MemberNameIterator vmni(*vmn);
+	MemberDef *vmd;
+	for (;(vmd=vmni.current());++vmni)
+	{
+	  if (vmd->isVariable() && vmd->memberClass()==vcd)
+	  {
+	    //printf("Found variable type=%s\n",vmd->typeString());
+	    ClassDef *mcd=stripClassName(vmd->typeString());
+	    if (mcd)
+	    {
+	      MemberName *mmn=memberNameDict[memName];
+	      if (mmn)
+	      {
+	      MemberNameIterator mmni(*mmn);
+	      MemberDef *mmd;
+	      for (;(mmd=mmni.current());++mmni)
+	      {
+		if (mmd->memberClass()==mcd)
+		{
+		  ol.writeCodeLink(mcd->getReference(),mcd->getOutputFileBase(),
+		      mmd->anchor(),memName);
+		  return;
+		}
+	      }
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  }
   ol.codify(memName);
   return;
 }
 
 static void generateFunctionLink(OutputList &ol,const char *funcName)
 {
-  //printf("generateFunctionLink(%s) classScope=%s\n",funcName,classScope.data());
   OutputList result(&ol);
   CodeClassDef *ccd=0;
-  if (classScope.length()>0 && (ccd=codeClassDict[classScope]))
+  QCString locScope=classScope.copy();
+  QCString locFunc=funcName;
+  int i=locFunc.findRev("::");
+  if (i>0)
+  {
+    locScope=locFunc.left(i);
+    locFunc=locFunc.right(locFunc.length()-i-2);
+  }
+  //printf("generateFunctionLink(%s) classScope=%s\n",locFunc.data(),locScope.data());
+  if (locScope.length()>0 && (ccd=codeClassDict[locScope]))
   {
     //printf("using classScope %s\n",classScope.data());
     char *s=ccd->bases.first();
     while (s)
     {
-      if (getLink(s,funcName,result)) 
+      if (getLink(s,locFunc,result,funcName)) 
       {
 	ol+=result;
 	return;
@@ -321,7 +377,7 @@ static void generateFunctionLink(OutputList &ol,const char *funcName)
       s=ccd->bases.next();
     }
   }
-  if (getLink(classScope,funcName,result))
+  if (getLink(locScope,locFunc,result,funcName))
   {
     ol+=result;
   }
@@ -332,6 +388,76 @@ static void generateFunctionLink(OutputList &ol,const char *funcName)
   return;
 }
 
+/*! counts the number of lines in the input */
+static int countLines()
+{
+  const char *p=inputString;
+  char c;
+  int count=1;
+  while ((c=*p++)) if (c=='\n') count++; 
+  return count;
+}
+
+static void startCodeLine()
+{
+  if (sourceFileDef)
+  {
+    QCString lineNumber,lineAnchor;
+    lineNumber.sprintf("%05d ",yyLineNr);
+    lineAnchor.sprintf("l%05d",yyLineNr);
+    //MemberDef *md = sourceFileDef->getSourceDefinition(yyLineNr);
+    //Definition *d=0;
+    //if (md)
+    //{
+    //  d=md->memberClass();
+    //  if (!d) d=md->getFileDef();
+    //}
+    //if (md && d)
+    Definition *d   = sourceFileDef->getSourceDefinition(yyLineNr);
+    QCString anchor = sourceFileDef->getSourceAnchor(yyLineNr);
+    if (d && d->isLinkableInProject())
+    {
+      code->startCodeAnchor(lineAnchor);
+      code->writeCodeLink(d->getReference(),d->getOutputFileBase(),
+	                   anchor,lineNumber);
+      code->endCodeAnchor();
+    }
+    else
+    {
+      code->codify(lineNumber);
+    }
+  }
+  code->startCodeLine(); 
+}
+
+static void codifyLines(char *text)
+{
+  char *p=text,*sp=p;
+  char c;
+  bool done=FALSE;
+  while (!done)
+  {
+    sp=p;
+    while ((c=*p++) && c!='\n');
+    if (c=='\n')
+    {
+      yyLineNr++;
+      *(p-1)='\0';
+      code->codify(sp);
+      code->endCodeLine();
+      if (yyLineNr<inputLines) 
+      {
+	startCodeLine();
+      }
+    }
+    else
+    {
+      code->codify(sp);
+      done=TRUE;
+    }
+  }
+}
+
 /* -----------------------------------------------------------------
  */
 #undef	YY_INPUT
@@ -350,16 +476,19 @@ static int yyread(char *buf,int max_size)
 
 %}
 
+B       [ \t]
+BN      [ \t\n\r]
 ID	[a-z_A-Z][a-z_A-Z0-9]*
+SCOPENAME (({ID}?{BN}*"::"{BN}*)*)((~{BN}*)?{ID})
 
 %option noyywrap
 
 %x      SkipString
 %x	SkipCPP
 %x	SkipComment
-%x	SkipSpecialComment
 %x	SkipCxxComment
-%x	SkipSpecialCxxComment
+%x	RemoveSpecialCComment
+%x	StripSpecialCComment
 %x	Body
 %x      FuncCall
 %x      MemberCall
@@ -373,12 +502,13 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 %%
 
 <*>\x0d
-<Body>^([ \t]*"#include"[ \t]*)("<"|"\"") {
+<Body>^([ \t]*"#"[ \t]"include"[ \t]*)("<"|"\"") {
 					  code->codify(yytext);
   					  BEGIN( ReadInclude ); 
 					}
 <Body>("class"|"struct"|"union")[ \t\n]+ { 
-					  code->codify(yytext);
+                                          codifyLines(yytext);
+					  //code->codify(yytext);
   					  BEGIN( ClassName ); 
 					}
 <ReadInclude>[a-z_A-Z0-9.]+(("/"[a-z_A-Z0-9.]+)*)/(">"|"\"")  {
@@ -408,12 +538,10 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
   					  code->codify(yytext);
 					}
 <SkipCPP>\\\n				{ 
-  					  code->codify(yytext);
-  					  yyLineNr++ ; 
+  					  codifyLines(yytext);
 					}
 <SkipCPP>\n				{ 
-					  yyLineNr++ ;
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
 					  BEGIN( Body ) ;
 					}
 <SkipCPP>"//"				{ 
@@ -447,7 +575,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 					  generateClassLink(*code,yytext);
 					}
 <ClassName>[ \t\n]*":"[ \t\n]*		{
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
   					  BEGIN( Bases ); 
 					}
 <Bases,ClassName>[ \t]*"{"[ \t]*	{
@@ -500,29 +628,33 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
   					
 
 <Body>("asm"|"auto"|"break"|"case"|"catch"|"continue"|"default"|"delete"|"do"|"else"|"for"|"goto"|"if"|"new"|"return"|"switch"|"this"|"throw"|"try"|"typedef"|"while")([ \t\n]*)/"(" {
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
   				          name.resize(0);type.resize(0);
   					}
 <Body>("asm"|"auto"|"break"|"case"|"catch"|"continue"|"default"|"delete"|"do"|"else"|"for"|"goto"|"if"|"new"|"return"|"switch"|"this"|"throw"|"try"|"typedef"|"while")([ \t\n]*) {
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
   				          name.resize(0);type.resize(0);
   					}
+  /*
 <Body>([a-z_A-Z~][a-z_A-Z0-9]*)/([ \t]*)	{ 
 					  generateClassLink(*code,yytext);
 					  addType();
   					  name+=yytext; 
 					}
-<Body>[a-z_A-Z~]([a-z_A-Z0-9]*[ \t\n]*"::")+[ \t\n]*[~a-z_A-Z][a-z_A-Z0-9]*[ \t\n]* { 
-  					  code->codify(yytext);
+  */
+<Body>{SCOPENAME}/[ \t\n]* { 
+					  generateClassLink(*code,yytext);
+  					  //codifyLines(yytext);
 					  addType();
   					  name+=yytext; 
 					}
-<Body>([a-z_A-Z~][a-z_A-Z0-9:]*)/([ \t]*"(")	{
+<Body>{SCOPENAME}/{B}*"("		{
   					  addType();
-					  if (type.length()==0)
-					    generateFunctionLink(*code,yytext);
-					  else
-  					    code->codify(yytext);
+					  //if (type.length()==0)
+					  QCString tmp=yytext;
+					  generateFunctionLink(*code,yytext);
+					  //else
+  					  //  code->codify(yytext);
   					  bracketCount=1;
 					  args.resize(0);
   					  name+=yytext; 
@@ -536,11 +668,14 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 <SkipString>[^\"\\]*			{ 
   					  code->codify(yytext);
 					}
+<SkipString>"//"|"/*"			{
+  					  code->codify(yytext);
+  					}
 <SkipString>\"				{
   					  code->codify(yytext);
   					  BEGIN( lastStringContext );
   					}
-<SkipString>\\\"			{
+<SkipString>\\.				{
   					  code->codify(yytext);
 					}
 <Body>":"				{
@@ -554,7 +689,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
   					  code->codify(yytext);
   					  BEGIN( MemberCall ); 
 					}
-<MemberCall>([a-z_A-Z~][a-z_A-Z0-9]*)/([ \t\n]*"(") {
+<MemberCall>{SCOPENAME}/{B}*"(" 	{
   					  if (name.length()>0)
 					    generateMemberLink(*code,name,yytext);
 					  else
@@ -563,7 +698,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 					  bracketCount=0;
 					  BEGIN(FuncCall);
   					}
-<MemberCall>[^a-z_A-Z0-9(]		{ 
+<MemberCall>[^a-z_A-Z0-9(\n]		{ 
   					  code->codify(yytext);
     					  type.resize(0);
 					  name.resize(0);
@@ -602,7 +737,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
   					  BEGIN( Body ); 
 					}
 <MemberCall2,FuncCall>")"[ \t\n]*";"	{
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
   					  bracketCount=0;
 					  if (!inClass && type.length()>0)
 					    addVariable();
@@ -614,7 +749,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 					  addParameter();
 					  parmType.resize(0);parmName.resize(0);
 					  if (name.length()>0) setClassScope(name);
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
 					  curlyCount++;
   					  type.resize(0); name.resize(0);
 					  BEGIN( Body );
@@ -623,7 +758,7 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 					  addParameter();
 					  parmType.resize(0);parmName.resize(0);
 					  if (name.length()>0) setClassScope(name);
-  					  code->codify(yytext);
+  					  codifyLines(yytext);
   					  type.resize(0); name.resize(0);
 					  BEGIN( SkipInits );
   					}
@@ -658,67 +793,118 @@ ID	[a-z_A-Z][a-z_A-Z0-9]*
 <SkipComment>"//"			{
   					  code->codify(yytext);
   					}
+<SkipComment>[^*/\n]+			{
+  					  code->codify(yytext);
+  					}
 <SkipComment>[ \t]*"*/"			{ 
   					  code->codify(yytext);
   					  BEGIN( lastCContext ) ; 
 					}
 <SkipCxxComment>.*\n			{ 
-  					  code->codify(yytext);
-  					  yyLineNr++ ;
+  					  codifyLines(yytext);
 					  BEGIN( lastCContext ) ;
 					}
-<SkipSpecialComment>"//"
-  /*!
-<SkipSpecialComment>[ \t]*"* /"[ \t]* /"\n" {
-  					  BEGIN( lastDContext ) ;
+<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)*{B}*"/*"[*!]/[^/*] {
+  					  yyLineNr+=QCString(yytext).contains('\n');
+					}
+<RemoveSpecialCComment>"*/"{B}*\n({B}*\n)* {
+  					  yyLineNr+=QCString(yytext).contains('\n');
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					  BEGIN(lastSpecialCContext);
   					}
-  */
-<SkipSpecialComment>[ \t]*"*/"		{
+<RemoveSpecialCComment>"*/"		{
+  					  BEGIN(lastSpecialCContext);
+  					}
+<RemoveSpecialCComment>[^*\n]+
+<RemoveSpecialCComment>"//"|"/*"
+<RemoveSpecialCComment>\n  { yyLineNr++; }
+<RemoveSpecialCComment>.
+  /*
+<SkipSpecialComment>"//"
+<SkipSpecialComment>[ \t]*"* /"		{
   					  BEGIN( lastDContext ) ;
   					}
-<SkipSpecialComment>[ \t]*"*/"[ \t\n]*"\n"/"/*"  {
+<SkipSpecialComment>[ \t]*"* /"[ \t\n]*"\n"/"/ *"  {
   					  //code->codify("\n");
-					  QCString lineText=yytext;
-  					  yyLineNr+=lineText.contains('\n');
+					  //QCString lineText=yytext;
+  					  //yyLineNr+=lineText.contains('\n');
   					  BEGIN( lastDContext ) ;
   					}
 <SkipSpecialComment>.	
-<SkipSpecialComment>\n			{ yyLineNr++; }
-<SkipSpecialCxxComment>.*/\n		{
-  					  yyLineNr++ ;
+<SkipSpecialComment>\n			{ 
+  					  codifyLines(yytext); 
+					}
+<SkipSpecialCxxComment>.* /\n		{
+  					  codifyLines(yytext); 
 					  BEGIN( lastDContext ) ;
   					}
 <SkipSpecialCxxComment>.	
-<SkipSpecialCxxComment>\n		{ yyLineNr++; }
-<*>[ \t]*"/*!"|"/**"			{
-  					  lastDContext = YY_START ;
-					  BEGIN( SkipSpecialComment );
+<SkipSpecialCxxComment>\n		{ 
+  					  codifyLines(yytext); 
+					}
+ */
+<*>\n({B}*"//"[!/][^\n]*\n)*		{ // remove special one-line comment
+  					  yyLineNr+=((QCString)yytext).contains('\n');
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					}
+<*>^{B}*"//"[!/][^\n]*\n		{ // remove special one-line comment
+  					  yyLineNr++;
+                                          code->endCodeLine();
+                                          if (yyLineNr<inputLines) 
+                                          {
+                                            startCodeLine();
+                                          }
+  					}
+<*>"//"[!/][^\n]*\n			{ // strip special one-line comment
+  					  char c[2]; c[0]='\n'; c[1]=0;
+  					  codifyLines(c);
+  					}
+<*>\n{B}*"/*"[!*]/[^/*]			{
+					  lastSpecialCContext = YY_START;
+					  yyLineNr++;
+					  BEGIN(RemoveSpecialCComment);
+					}
+<*>^{B}*"/*"[!*]/[^/*]			{ // special C comment block at a new line
+					  lastSpecialCContext = YY_START;
+					  BEGIN(RemoveSpecialCComment);
+					}
+<*>"/*"[!*]/[^/*]			{ // special C comment block half way a line
+					  lastSpecialCContext = YY_START;
+					  BEGIN(RemoveSpecialCComment);
 					}
 <*>"/*"					{ 
   					  code->codify(yytext);
   					  lastCContext = YY_START ;
 					  BEGIN( SkipComment ) ;
 					}
-<*>[ \t]*"//!"				{
-  					  lastDContext = YY_START ;
-					  BEGIN( SkipSpecialCxxComment );
-  					}
 <*>"//"					{ 
   					  code->codify(yytext);
   					  lastCContext = YY_START ;
 					  BEGIN( SkipCxxComment ) ;
 					}
+<*>\n					{
+  					  codifyLines(yytext); 
+  					}
 <*>.					{
   					  code->codify(yytext);
 					}
-<*>\n					{
-  					  code->codify(yytext);
-  					}
+  /*
 <*>([ \t\n]*"\n"){2,}			{ // combine multiple blank lines
-  					  QCString sepLine=yytext;
-  					  code->codify("\n\n");
-  					  yyLineNr+=sepLine.contains('\n'); 
+  					  //QCString sepLine=yytext;
+  					  //code->codify("\n\n");
+  					  //yyLineNr+=sepLine.contains('\n'); 
+  					  //char sepLine[3]="\n\n";
+  					  codifyLines(yytext);
 					}
+  */
 
 %%
 
@@ -739,20 +925,23 @@ void initParseCodeContext()
 }
 
 void parseCode(OutputList &ol,const char *className,const QCString &s, 
-                  bool e, const char *exName)
+                  bool exBlock, const char *exName,FileDef *fd)
 {
   code = new OutputList(&ol);
   if (s.length()==0) return;
   inputString   = s;
   inputPosition = 0;
-  yyLineNr      = 0;
+  inputLines    = countLines();
+  yyLineNr      = 1;
   curlyCount    = 0;
   bracketCount  = 0;
   sharpCount    = 0;
   classScope    = className;
-  exampleBlock  = e; 
+  exampleBlock  = exBlock; 
   exampleName   = exName;
+  sourceFileDef = fd;
   exampleFile   = convertSlashes(exampleName,TRUE)+"-example";
+  startCodeLine();
   type.resize(0);
   name.resize(0);
   args.resize(0);
@@ -761,6 +950,7 @@ void parseCode(OutputList &ol,const char *className,const QCString &s,
   codeYYrestart( codeYYin );
   BEGIN( Body );
   codeYYlex();
+  //if (yyLineNr<=inputLines) code->endCodeLine();
   ol+=*code;
   delete code;
   return;
diff --git a/src/config.cpp b/src/config.cpp
new file mode 100644
author	cvs2svn <tools@python.org>	1996-10-25 15:40:20 (GMT)
committer	cvs2svn <tools@python.org>	1996-10-25 15:40:20 (GMT)
commit	6c3a3aa17b028f6b93067083d32c7eaa4338757c (patch)
tree	416b434cadec883c68be3897203da0aaa9066839 /Grammar
parent	61f9139125d0b0aadc6f452e197721ec9de9236a (diff)
download	cpython-1.4.zip cpython-1.4.tar.gz cpython-1.4.tar.bz2