%{
#include <stdio.h>
#include <ctype.h>

static void yyerror(char *message);
static int yylex(void);
static void next_input(void);
static void add_item(void);
static int check_reserved(void);
static int c_old = ' ';
static int c_new = ' ';
static int linenum = 1;
static int columnnum = -1;
static char item[255];
static int len;
%}

%start list

%union { char *strtype; }

%token <strtype> IDENTIFIER
%token <strtype> CLASS_NAME
%token <strtype> ENUM_NAME
%token <strtype> TYPEDEF_NAME
%token <strtype> INTEGER_CONSTANT
%token <strtype> FLOATING_CONSTANT
%token <strtype> CHARACTER_CONSTANT
%token <strtype> STRING_LITERAL
%token <strtype> COMMENT
%token <strtype> FILELINE

%token <strtype> '{'
%token <strtype> '}'
%token <strtype> ')'
%token <strtype> '('
%token <strtype> ']'
%token <strtype> '['
%token <strtype> '+'
%token <strtype> '-'
%token <strtype> '*'
%token <strtype> '/'
%token <strtype> '%'
%token <strtype> '^'
%token <strtype> '&'
%token <strtype> '|'
%token <strtype> '.'
%token <strtype> ','
%token <strtype> ';'
%token <strtype> ':'
%token <strtype> '?'
%token <strtype> '~'
%token <strtype> '='
%token <strtype> DASHGTR
%token <strtype> DASHGTRSTAR
%token <strtype> PLUSPLUS
%token <strtype> MINUSMINUS
%token <strtype> DOTSTAR
%token <strtype> LESSEQU
%token <strtype> GTREQU
%token <strtype> EQUEQU
%token <strtype> NOTEQU
%token <strtype> TILDEEQU
%token <strtype> COLONCOLON
%token <strtype> LSHIFT
%token <strtype> LSHIFTEQU
%token <strtype> RSHIFT
%token <strtype> RSHIFTEQU
%token <strtype> PLUSEQU
%token <strtype> MINUSEQU
%token <strtype> TIMESEQU
%token <strtype> DIVEQU
%token <strtype> MODEQU
%token <strtype> HATEQU
%token <strtype> ANDEQU
%token <strtype> OREQU
%token <strtype> ELLIPSIS
%token <strtype> DOTDOT
%token <strtype> ANDAND
%token <strtype> OROR

%token <strtype> ASM
%token <strtype> AUTO
%token <strtype> BREAK
%token <strtype> CASE
%token <strtype> CATCH
%token <strtype> CHAR
%token <strtype> CLASS
%token <strtype> CONST
%token <strtype> CONTINUE
%token <strtype> DEFAULT
%token <strtype> DELETE
%token <strtype> DO
%token <strtype> DOUBLE
%token <strtype> ELSE
%token <strtype> ENUM
%token <strtype> EXTERN
%token <strtype> FLOAT
%token <strtype> FOR
%token <strtype> FRIEND
%token <strtype> GOTO
%token <strtype> IF
%token <strtype> INLINE
%token <strtype> INT
%token <strtype> LONG
%token <strtype> NEW
%token <strtype> OPERATOR
%token <strtype> PRIVATE
%token <strtype> PROTECTED
%token <strtype> PUBLIC
%token <strtype> REGISTER
%token <strtype> RETURN
%token <strtype> SHORT
%token <strtype> SIGNED
%token <strtype> SIZEOF
%token <strtype> STATIC
%token <strtype> STRUCT
%token <strtype> SWITCH
%token <strtype> TEMPLATE
%token <strtype> THIS
%token <strtype> THROW
%token <strtype> TRY
%token <strtype> TYPEDEF
%token <strtype> UNION
%token <strtype> UNSIGNED
%token <strtype> VIRTUAL
%token <strtype> VOID
%token <strtype> VOLATILE
%token <strtype> WHILE

%token           NEWLINE
%token           CONTROL

%%   /* beginning of rules section */

list	:	/* empty */
	|	list declaration_list ';'
	|	list COMMENT
			{ printf( "%s ",$<strtype>2); }
	|	list FILELINE
			{ printf( "%s ",$<strtype>2); }
	|	list NEWLINE
			{ printf( "\n"); }
	|	list CONTROL
			{ printf( "\n"); }
	|	list error '\0'
			{	yyerrok; }
	;
expression
	:	assignment_expression
	|	expression ',' assignment_expression
	;
assignment_expression
	:	conditional_expression
	|	unary_expression assignment_operator assignment_expression
	;
assignment_operator
	:	'='
			{ printf( "%s ",$<strtype>1); }
	|	TIMESEQU
			{ printf( "%s ",$<strtype>1); }
	|	DIVEQU
			{ printf( "%s ",$<strtype>1); }
	|	MODEQU
			{ printf( "%s ",$<strtype>1); }
	|	PLUSEQU
			{ printf( "%s ",$<strtype>1); }
	|	MINUSEQU
			{ printf( "%s ",$<strtype>1); }
	|	RSHIFTEQU
			{ printf( "%s ",$<strtype>1); }
	|	LSHIFTEQU
			{ printf( "%s ",$<strtype>1); }
	|	ANDEQU
			{ printf( "%s ",$<strtype>1); }
	|	HATEQU
			{ printf( "%s ",$<strtype>1); }
	|	OREQU
			{ printf( "%s ",$<strtype>1); }
	;
conditional_expression
	:	logical_or_expression
	|	logical_or_expression '?' expression ':' conditional_expression
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	;
logical_or_expression
	:	logical_and_expression
	|	logical_or_expression OROR logical_and_expression
			{ printf( "%s ",$<strtype>2); }
	;
logical_and_expression
	:	inclusive_or_expression
	|	logical_and_expression ANDAND inclusive_or_expression
			{ printf( "%s ",$<strtype>2); }
	;
inclusive_or_expression
	:	exclusive_or_expression
	|	inclusive_or_expression '|' exclusive_or_expression
			{ printf( "%s ",$<strtype>2); }
	;
exclusive_or_expression
	:	and_expression
	|	exclusive_or_expression '^' and_expression
			{ printf( "%s ",$<strtype>2); }
	;
and_expression
	:	equality_expression
	|	and_expression '&' equality_expression
			{ printf( "%s ",$<strtype>2); }
	;
equality_expression
	:	relational_expression
	|	equality_expression EQUEQU relational_expression
			{ printf( "%s ",$<strtype>2); }
	|	equality_expression NOTEQU relational_expression
			{ printf( "%s ",$<strtype>2); }
	;
relational_expression
	:	shift_expression
	|	relational_expression '<' shift_expression
			{ printf( "%s ",$<strtype>2); }
	|	relational_expression '>' shift_expression
			{ printf( "%s ",$<strtype>2); }
	|	relational_expression GTREQU shift_expression
			{ printf( "%s ",$<strtype>2); }
	|	relational_expression LESSEQU shift_expression
			{ printf( "%s ",$<strtype>2); }
	;
shift_expression
	:	additive_expression
	|	shift_expression LSHIFT additive_expression
			{ printf( "%s ",$<strtype>2); }
	|	shift_expression RSHIFT additive_expression
			{ printf( "%s ",$<strtype>2); }
	;
additive_expression
	:	multiplicative_expression
	|	additive_expression '+' multiplicative_expression
			{ printf( "%s ",$<strtype>2); }
	|	additive_expression '-' multiplicative_expression
			{ printf( "%s ",$<strtype>2); }
	;
multiplicative_expression
	:	pm_expression
	|	multiplicative_expression '*' pm_expression
			{ printf( "%s ",$<strtype>2); }
	|	multiplicative_expression '/' pm_expression
			{ printf( "%s ",$<strtype>2); }
	|	multiplicative_expression '%' pm_expression
			{ printf( "%s ",$<strtype>2); }
	;
pm_expression
	:	cast_expression
	|	pm_expression DOTSTAR cast_expression
			{ printf( "%s ",$<strtype>2); }
	|	pm_expression DASHGTRSTAR cast_expression
			{ printf( "%s ",$<strtype>2); }
	;
cast_expression
	:	unary_expression
	|	'(' type_name ')' unary_expression  /*jss*/
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	;
unary_expression
	:	postfix_expression
	|	PLUSPLUS unary_expression
			{ printf( "%s ",$<strtype>1); }
	|	MINUSMINUS unary_expression
			{ printf( "%s ",$<strtype>1); }
	|	unary_operator cast_expression
	|	SIZEOF unary_expression
			{ printf( "%s ",$<strtype>1); }
	|	SIZEOF '(' type_name ')'
			{ printf( "%s ",$<strtype>1); }
	;
unary_operator
	:	'*'
			{ printf( "%s ",$<strtype>1); }
	|	'&'
			{ printf( "%s ",$<strtype>1); }
	|	'+'
			{ printf( "%s ",$<strtype>1); }
	|	'-'
			{ printf( "%s ",$<strtype>1); }
	|	'!'
			{ printf( "%s ",$<strtype>1); }
	|	'~'
			{ printf( "%s ",$<strtype>1); }
	;
postfix_expression
	:	primary_expression
	|	postfix_expression '[' expression ']'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	postfix_expression '(' expression_list ')'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	simple_type_name '(' expression_list ')'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	postfix_expression '.' name
			{ printf( "%s ",$<strtype>2); }
	|	postfix_expression DASHGTR name
			{ printf( "%s ",$<strtype>2); }
	|	postfix_expression PLUSPLUS
			{ printf( "%s ",$<strtype>2); }
	|	postfix_expression MINUSMINUS
			{ printf( "%s ",$<strtype>2); }
	;
expression_list
	:	assignment_expression
	|	expression_list ',' assignment_expression
			{ printf( "%s ",$<strtype>2); }
	;
primary_expression
	:	literal
	|	'(' expression ')'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	|	name
	;
name
	:	IDENTIFIER
			{ printf( "%s ",$<strtype>1); }
	;
literal
	:	INTEGER_CONSTANT
			{ printf( "%s ",$<strtype>1); }
	|	FLOATING_CONSTANT
			{ printf( "%s ",$<strtype>1); }
	|	CHARACTER_CONSTANT
			{ printf( "%s ",$<strtype>1); }
	|	STRING_LITERAL
			{ printf( "%s ",$<strtype>1); }
	;


qualified_name
	:	qualified_class_name COLONCOLON name
			{ printf( "%s ",$<strtype>2); }
	;
declaration
	:	decl_specifiers ';'
			{ printf( "%s ",$<strtype>2); }
	|	declarator_list ';'
			{ printf( "%s ",$<strtype>2); }
	|	decl_specifiers declarator_list ';'
			{ printf( "%s ",$<strtype>3); }
	|	asm_declaration
	|	function_definition
	|	linkage_specification
	;
decl_specifier
	:	storage_class_specifier
	|	type_specifier
	|	fct_specifier
	|	FRIEND
			{ printf( "%s ",$<strtype>1); }
	|	TYPEDEF
			{ printf( "%s ",$<strtype>1); }
	;
decl_specifiers
	:	decl_specifier
	|	decl_specifiers decl_specifier
	;
storage_class_specifier
	:	AUTO
			{ printf( "%s ",$<strtype>1); }
	|	REGISTER
			{ printf( "%s ",$<strtype>1); }
	|	STATIC
			{ printf( "%s ",$<strtype>1); }
	|	EXTERN
			{ printf( "%s ",$<strtype>1); }
	;
fct_specifier
	:	INLINE
			{ printf( "%s ",$<strtype>1); }
	|	VIRTUAL
			{ printf( "%s ",$<strtype>1); }
	;
type_specifier
	:	simple_type_name
	|	class_specifier
	|	enum_specifier
	|	elaborated_type_specifier
	|	CONST
			{ printf( "%s ",$<strtype>1); }
	|	VOLATILE
			{ printf( "%s ",$<strtype>1); }
	;
simple_type_name
	:	complete_class_name
	|	qualified_type_name
	|	CHAR
			{ printf( "%s ",$<strtype>1); }
	|	SHORT
			{ printf( "%s ",$<strtype>1); }
	|	INT
			{ printf( "%s ",$<strtype>1); }
	|	LONG
			{ printf( "%s ",$<strtype>1); }
	|	SIGNED
			{ printf( "%s ",$<strtype>1); }
	|	UNSIGNED
			{ printf( "%s ",$<strtype>1); }
	|	FLOAT
			{ printf( "%s ",$<strtype>1); }
	|	DOUBLE
			{ printf( "%s ",$<strtype>1); }
	|	VOID
			{ printf( "%s ",$<strtype>1); }
	;
elaborated_type_specifier
	:	class_key IDENTIFIER
			{ printf( "%s ",$<strtype>2); }
	|	class_key CLASS_NAME
			{ printf( "%s ",$<strtype>2); }
	|	ENUM ENUM_NAME
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	;
class_key
	:	CLASS
			{ printf( "%s ",$<strtype>1); }
	|	STRUCT
			{ printf( "%s ",$<strtype>1); }
	|	UNION
			{ printf( "%s ",$<strtype>1); }
	;
qualified_type_name
	:	TYPEDEF_NAME
			{ printf( "%s ",$<strtype>1); }
	|	CLASS_NAME COLONCOLON qualified_type_name
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	;
complete_class_name
	:	qualified_class_name
/*	|	COLONCOLON qualified_class_name ? jss*/
	;
qualified_class_name
	:	CLASS_NAME
			{ printf( "%s ",$<strtype>1); }
	|	CLASS_NAME COLONCOLON qualified_class_name
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	;
enum_specifier
	:	ENUM ENUM_NAME '{' enum_list '}' /*jss*/
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	;
enum_list
	:	enumerator
	|	enum_list ',' enumerator
			{ printf( "%s ",$<strtype>2); }
	;
enumerator
	:	IDENTIFIER
			{ printf( "%s ",$<strtype>1); }
	|	IDENTIFIER '=' constant_expression
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	;
constant_expression
	:	conditional_expression
	;
linkage_specification
	:	EXTERN STRING_LITERAL '{' declaration_list '}'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	|	EXTERN STRING_LITERAL declaration
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	;
declaration_list
	:	declaration
	|	declaration_list declaration
	|	declaration_list statement_list
	;
asm_declaration
	:	ASM '(' STRING_LITERAL ')' ';'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>3);
			  printf( "%s ",$<strtype>4);
			  printf( "%s ",$<strtype>5); }
	;
declarator_list
	:	init_declarator
	|	declarator_list ',' init_declarator
			{ printf( "%s ",$<strtype>2); }
	;
init_declarator
	:	declarator
	|	declarator initializer
	;
declarator
	:	dname
	|	ptr_operator declarator
	|	declarator '(' argument_declaration_list ')' cv_qualifier_list
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	declarator '(' argument_declaration_list ')'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	declarator '[' constant_expression ']'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	declarator '[' ']'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>3); }
	|	'(' declarator ')'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	;
ptr_operator
	:	'*' cv_qualifier_list
			{ printf( "%s ",$<strtype>1); }
	|	'*'
			{ printf( "%s ",$<strtype>1); }
	|	'&' cv_qualifier_list
			{ printf( "%s ",$<strtype>1); }
	|	'&'
			{ printf( "%s ",$<strtype>1); }
	|	complete_class_name COLONCOLON '*' cv_qualifier_list
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>3); }
	|	complete_class_name COLONCOLON '*'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>3); }
	;
cv_qualifier_list
	:	cv_qualifier
	|	cv_qualifier_list cv_qualifier /*jss*/
	;
cv_qualifier
	:	CONST
			{ printf( "%s ",$<strtype>1); }
	|	VOLATILE
			{ printf( "%s ",$<strtype>1); }
	;
dname
	:	name
	|	CLASS_NAME
			{ printf( "%s ",$<strtype>1); }
	|	'~' CLASS_NAME
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	|	TYPEDEF_NAME
			{ printf( "%s ",$<strtype>1); }
	|	qualified_type_name /*jss*/
	;
type_name
	:	type_specifier_list
	|	type_specifier_list abstract_declarator
	;
type_specifier_list
	:	type_specifier
	|	type_specifier_list type_specifier
	;
abstract_declarator
	:	ptr_operator abstract_declarator
	|	ptr_operator
	|	abstract_declarator '(' argument_declaration_list ')' cv_qualifier_list
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	'(' argument_declaration_list ')' cv_qualifier_list
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	|	abstract_declarator '(' argument_declaration_list ')'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	'(' argument_declaration_list ')'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	|	abstract_declarator '[' constant_expression ']'
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	'[' constant_expression ']'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	|	'[' ']'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	|	'{' abstract_declarator '}'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	;
argument_declaration_list
	:	arg_declaration_list ELLIPSIS
			{ printf( "%s ",$<strtype>2); }
	|	ELLIPSIS
			{ printf( "%s ",$<strtype>1); }
	|	arg_declaration_list
	|	arg_declaration_list ',' ELLIPSIS
			{ printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>3); }
	;
arg_declaration_list
	:	argument_declaration
	|	arg_declaration_list ',' argument_declaration
			{ printf( "%s ",$<strtype>2); }
	;
argument_declaration
	:	decl_specifiers declarator
	|	decl_specifiers declarator '=' expression
			{ printf( "%s ",$<strtype>2); }
	|	decl_specifiers abstract_declarator
	|	decl_specifiers
	|	decl_specifiers abstract_declarator '=' expression
			{ printf( "%s ",$<strtype>3); }
	|	decl_specifiers '=' expression
			{ printf( "%s ",$<strtype>2); }
	;
function_definition
	:	decl_specifiers declarator ctor_initializer fct_body
	|	declarator ctor_initializer fct_body
	|	decl_specifiers declarator fct_body
	|	declarator fct_body
	;
fct_body
	:	compound_statement
	;
initializer
	:	'=' assignment_expression
			{ printf( "%s ",$<strtype>1); }
	|	'=' '{' initializer_list '}'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2);
			  printf( "%s ",$<strtype>4); }
	|	'=' '{' initializer_list ',' '}'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>2); }
	|	'(' expression_list ')'
			{ printf( "%s ",$<strtype>1);
			  printf( "%s ",$<strtype>3); }
	;
initializer_list
	:	assignment_expression
	|	initializer_list ',' assignment_expression
	|	'{' initializer_list '}'
	|	'{' initializer_list ',' '}'
	;
class_specifier
	:	class_head '{' member_list '}'
	|	class_head '{' '}'
	;
class_head
	:	class_key IDENTIFIER base_spec
	|	class_key base_spec
	|	class_key IDENTIFIER
	|	class_key
	|	class_key CLASS_NAME base_spec
	|	class_key CLASS_NAME
	;
member_list
	:	member_declaration
	|	member_list member_declaration
	|	access_specifier ':' member_list /* right recursion */
	;
member_declaration
	:	decl_specifiers member_declarator_list ';'
	|	member_declarator_list ';'
	|	decl_specifiers ';'
	|	';'
	|	function_definition ';'
	|	function_definition
	|	qualified_name ';'
	;
member_declarator_list
	:	member_declarator
	|	member_declarator_list ',' member_declarator
	;
member_declarator
	:	declarator pure_specifier
	|	declarator
	|	IDENTIFIER ':' constant_expression
	|	':' constant_expression
	;
pure_specifier
	:	'=' '0'
	;
base_spec
	:	base_list
	;
base_list
	:	base_specifier
	|	base_list ',' base_specifier
	;
base_specifier
	:	complete_class_name
	|	VIRTUAL access_specifier complete_class_name
	|	VIRTUAL complete_class_name
	|	access_specifier VIRTUAL complete_class_name
	|	access_specifier complete_class_name
	;
access_specifier
	:	PRIVATE
	|	PROTECTED
	|	PUBLIC
	;
ctor_initializer
	:	':' mem_initializer_list
	;
mem_initializer_list
	:	mem_initializer
	|	mem_initializer_list ',' mem_initializer /*jss*/
	;
mem_initializer
	:	complete_class_name '(' expression_list ')'
	|	complete_class_name '(' ')'
	|	IDENTIFIER '(' expression_list ')'
	|	IDENTIFIER '(' ')'
	;
statement
	:	labeled_statement
	|	expression_statement
	|	compound_statement
	|	selection_statement
	|	iteration_statement
	|	jump_statement
	;
labeled_statement
	:	IDENTIFIER ':' statement
	|	CASE constant_expression ':' statement
	|	DEFAULT ':' statement
	;
expression_statement
	:	expression ';'
	;
compound_statement
	:	'{' statement_list '}'
	;
statement_list
	:	statement
	|	statement_list statement
	;
selection_statement
	:	IF '(' expression ')' statement ELSE statement
	|	IF '(' expression ')' statement
	|	SWITCH '(' expression ')' statement
	;
iteration_statement
	:	WHILE '(' expression ')' statement
	|	DO statement WHILE '(' expression ')' ';'
	|	FOR '(' for_init_statement expression ';' expression ')' statement
	;
for_init_statement
	:	expression_statement
	|	declaration_statement
	;
jump_statement
	:	BREAK ';'
	|	CONTINUE ';'
	|	RETURN expression ';'
	|	RETURN ';'
	|	GOTO IDENTIFIER ';'
	;
declaration_statement
	:	declaration
	;

%%  /* start of program */
int main(void)
{
	return yyparse();
}

static void yyerror(char *message)
{
	printf("\n yyerror: %s \n", message);
}

static int yylex(void){
	int  c;
	int  intflt=0;

	len = -1;
        item[0] = 0;

	yylval.strtype = item;

	if(c_old == ' '){
		for(;;){
			next_input();
			if(c_old != ' ') break;
		}
	}

	/* printf("\n read non blank = %c %d \n", c_old, c_old); */

	/* FILELINE */
	if(c_old == '#' && columnnum == 1 ){
		add_item();
		for(;;){
			if(c_old == '\n') break;
			add_item();
		}
		return (FILELINE) ;
	}

	/* COMMENT C++ // */
	if(c_old == '/' && c_new == '/'){
		add_item();
		for(;;){
			if(c_old == '\n') break;
			add_item();
		}
		return (COMMENT) ;
	}

	/* COMMENT  C */
	if(c_old == '/' && c_new == '*'){
		add_item();
		add_item();
		for(;;){
			if(c_old == '*' && c_new == '/'){
				add_item();
				add_item();
				break;
			}
			else add_item();
		}
		return (COMMENT) ;
	}

	/* IDENTIFIER */
	if(isalpha(c_old) || c_old == '_'){
		add_item();
		for(;;){
			if(isalnum(c_old) || c_old == '_') add_item();
			else break;
		}
		c = 0;
		if(len>=2 && len<=9) c = check_reserved();
		if(c != 0) return c;
		return (IDENTIFIER) ;
	}

	/* INTEGER or FLOATING_CONSTANT */
	if(isdigit(c_old) || (c_old == '.' && isdigit(c_new))){
		add_item();
		if(c_old == '.') intflt = 1;
		for(;;){
			if(c_old == '.') {
				add_item();
				intflt = 1; /* have a float */
			}
			else if(c_old == 'x' || c_old == 'X' ) {
				add_item();
				intflt = -1; /* have an integer */
			}
			else if(c_old == 'e' || c_old == 'E') {
				add_item();
				if(intflt >= 0) intflt=2; /* have scientific */
			}
			else if(c_old == '+' || c_old == '-') {
				if(intflt == 2) add_item();
				else break;
			}
			else if(isdigit(c_old) || 
			   c_old == 'a' || c_old == 'A' || 
			   c_old == 'b' || c_old == 'B' || 
			   c_old == 'c' || c_old == 'C' || 
			   c_old == 'd' || c_old == 'D' || 
			   c_old == 'f' || c_old == 'F' ||
			   c_old == 'l' || c_old == 'L' ||
			   c_old == 'u' || c_old == 'U' ) add_item();
			else break;
		}
		if(intflt >= 1) return (FLOATING_CONSTANT) ;
		else return (INTEGER_CONSTANT) ;
	}

	/* STRING_LITERAL */
	if(c_old == '\"'){
		add_item();
		for(;;){
			if(c_old != '\"'){
				add_item();
			}
			else if(c_old == '\"' && c_new == '\"'){
				add_item();
				add_item(); /* keep doubles for now */
			}
			else{  /* c_old=='\"' thus end string */
				add_item();
				break;
			}
		}
		return (STRING_LITERAL) ;
	}

	/* CHARACTER_CONSTANT */
	if(c_old == '\''){
		add_item();
		for(;;){
			if(c_old = '\''){
				add_item();
				break;
			}
			else 	add_item();
		}
		return (CHARACTER_CONSTANT) ;
	}

	/* NEWLINE */
	if(c_old == '\n'){
		next_input();
		return (NEWLINE);
	}

	/* PUNCTUATION  single characters are themselves */
	if(ispunct(c_old) && c_old > 32){
		add_item();
		if(item[0] == '-' && c_old == '>') {
			add_item();
			if(c_old == '*') {
				add_item();
				return (DASHGTRSTAR);
			}
			return (DASHGTR);
		}
		else if(item[0] == '+' && c_old == '+') {
			add_item();
			return (PLUSPLUS);
		}
		else if(item[0] == '-' && c_old == '-') {
			add_item();
			return (MINUSMINUS);
		}
		else if(item[0] == '.' && c_old == '*') {
			add_item();
			return (DOTSTAR);
		}
		else if(item[0] == '<' && c_old == '<') {
			add_item();
			if(c_old == '=') {
				add_item();
				return (RSHIFTEQU);
			}
			return (RSHIFT);
		}
		else if(item[0] == '>' && c_old == '>') { 
			add_item();
			if(c_old == '=') {
				add_item();
				return (LSHIFTEQU);
			}
			return (LSHIFT);
		}
		else if(item[0] == '<' && c_old == '=') {
			add_item();
			return (LESSEQU);
		}
		else if(item[0] == '>' && c_old == '=') {
			add_item();
			return (GTREQU);
		}
		else if(item[0] == '=' && c_old == '=') {
			add_item();
			return (EQUEQU);
		}
		else if(item[0] == '!' && c_old == '=') {
			add_item();
			return (NOTEQU);
		}
		else if(item[0] == '&' && c_old == '&') {
			add_item();
			return (ANDAND);
		}
		else if(item[0] == '|' && c_old == '|') {
			add_item();
			return (OROR);
		}
		else if(item[0] == '*' && c_old == '=') {
			add_item();
			return (TIMESEQU);
		}
		else if(item[0] == '/' && c_old == '=') {
			add_item();
			return (DIVEQU);
		}
		else if(item[0] == '%' && c_old == '=') {
			add_item();
			return (MODEQU);
		}
		else if(item[0] == '+' && c_old == '=') {
			add_item();
			return (PLUSEQU);
		}
		else if(item[0] == '-' && c_old == '=') {
			add_item();
			return (MINUSEQU);
		}
		else if(item[0] == '&' && c_old == '=') {
			add_item();
			return (ANDEQU);
		}
		else if(item[0] == '|' && c_old == '=') {
			add_item();
			return (OREQU);
		}
		else if(item[0] == '^' && c_old == '=') {
			add_item();
			return (HATEQU);
		}
		else if(item[0] == '~' && c_old == '=') {
			add_item();
			return (TILDEEQU);
		}
		else if(item[0] == ':' && c_old == ':') {
			add_item();
			return (COLONCOLON);
		}
		else if(item[0] == '.' && c_old == '.') {
			add_item();
			if(c_old == '.') {  
				add_item();
				return (ELLIPSIS);
			}
			return (DOTDOT);
		} 
		else if(item[0] == '?' && c_old == '?') {
			next_input();
			next_input();
			if(c_new == '=')  item[0] = '#'; 
			if(c_new == '/')  item[0] = '\\'; 
			if(c_new == '\'') item[0] = '^'; 
			if(c_new == '(')  item[0] = '['; 
			if(c_new == ')')  item[0] = ']'; 
			if(c_new == '!')  item[0] = '|'; 
		}
		return (item[0]); /* character represents itself */
	}

	/* CONTROL characters */
	else{
		if(c_old <= 0) return(c_old);
		c = c_old;
		next_input();
		return (CONTROL);
	}
}

static void next_input(void)
{
	if(c_old == '\n'){ linenum++; columnnum = 0; }
	c_old = c_new;
	c_new = fgetc(stdin);
	columnnum++;	
	/* printf("\n c_old = %c %d  linenum= %d  columnnum= %d \n",
	c_old, c_old, linenum, columnnum); */

}

static void add_item(void)
{
	item[++len] = c_old;
	item[len+1] = 0;
	next_input();
}

static int check_reserved(void)
{
  switch(len){
    case 2:
	if(!strcmp(item,"do")) return (DO);
	if(!strcmp(item,"if")) return (IF);
	break;
    case 3:
	if(!strcmp(item,"asm")) return (ASM);
	if(!strcmp(item,"for")) return (FOR);
	if(!strcmp(item,"int")) return (INT);
	if(!strcmp(item,"new")) return (NEW);
	if(!strcmp(item,"try")) return (TRY);
	break;
    case 4:
	if(!strcmp(item,"auto")) return (AUTO);
	if(!strcmp(item,"else")) return (ELSE);
	if(!strcmp(item,"case")) return (CASE);
	if(!strcmp(item,"char")) return (CHAR);
	if(!strcmp(item,"enum")) return (ENUM);
	if(!strcmp(item,"goto")) return (GOTO);
	if(!strcmp(item,"long")) return (LONG);
	if(!strcmp(item,"this")) return (THIS);
	if(!strcmp(item,"void")) return (VOID);
	break;
    case 5:
	if(!strcmp(item,"break")) return (BREAK);
	if(!strcmp(item,"catch")) return (CATCH);
	if(!strcmp(item,"class")) return (CLASS);
	if(!strcmp(item,"const")) return (CONST);
	if(!strcmp(item,"float")) return (FLOAT);
	if(!strcmp(item,"short")) return (SHORT);
	if(!strcmp(item,"throw")) return (THROW);
	if(!strcmp(item,"while")) return (WHILE);
	if(!strcmp(item,"union")) return (UNION);
	break;
    case 6:
	if(!strcmp(item,"delete")) return (DELETE);
	if(!strcmp(item,"double")) return (DOUBLE);
	if(!strcmp(item,"extern")) return (EXTERN);
	if(!strcmp(item,"friend")) return (FRIEND);
	if(!strcmp(item,"inline")) return (INLINE);
	if(!strcmp(item,"public")) return (PUBLIC);
	if(!strcmp(item,"return")) return (RETURN);
	if(!strcmp(item,"signed")) return (SIGNED);
	if(!strcmp(item,"sizeof")) return (SIZEOF);
	if(!strcmp(item,"static")) return (STATIC);
	if(!strcmp(item,"struct")) return (STRUCT);
	if(!strcmp(item,"switch")) return (SWITCH);
	break;
    case 7:
	if(!strcmp(item,"private")) return (PRIVATE);
	if(!strcmp(item,"default")) return (DEFAULT);
	if(!strcmp(item,"typedef")) return (TYPEDEF);
	if(!strcmp(item,"virtual")) return (VIRTUAL);
	break;
    case 8:
	if(!strcmp(item,"operator")) return (OPERATOR);
	if(!strcmp(item,"template")) return (TEMPLATE);
	if(!strcmp(item,"register")) return (REGISTER);
	if(!strcmp(item,"unsigned")) return (UNSIGNED);
	if(!strcmp(item,"volatile")) return (VOLATILE);
	if(!strcmp(item,"continue")) return (CONTINUE);
	break;
    case 9:
	if(!strcmp(item,"protected")) return (PROTECTED);
  }
  return 0;
}