4718 lines
125 KiB
C
4718 lines
125 KiB
C
/* Separate lexical analyzer for GNU C++.
|
||
Copyright (C) 1987, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
|
||
Hacked by Michael Tiemann (tiemann@cygnus.com)
|
||
|
||
This file is part of GNU CC.
|
||
|
||
GNU CC 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.
|
||
|
||
GNU CC 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 GNU CC; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 59 Temple Place - Suite 330,
|
||
Boston, MA 02111-1307, USA. */
|
||
|
||
|
||
/* This file is the lexical analyzer for GNU C++. */
|
||
|
||
/* Cause the `yydebug' variable to be defined. */
|
||
#define YYDEBUG 1
|
||
|
||
#include <sys/types.h>
|
||
#include <stdio.h>
|
||
#include <errno.h>
|
||
#include <setjmp.h>
|
||
#include "config.h"
|
||
#include "input.h"
|
||
#include "tree.h"
|
||
#include "lex.h"
|
||
#include "parse.h"
|
||
#include "cp-tree.h"
|
||
#include "flags.h"
|
||
#include "obstack.h"
|
||
#include "c-pragma.h"
|
||
|
||
#ifdef MULTIBYTE_CHARS
|
||
#include <stdlib.h>
|
||
#include <locale.h>
|
||
#endif
|
||
|
||
#ifndef errno
|
||
extern int errno; /* needed for VAX. */
|
||
#endif
|
||
extern jmp_buf toplevel;
|
||
|
||
#define obstack_chunk_alloc xmalloc
|
||
#define obstack_chunk_free free
|
||
|
||
extern struct obstack *expression_obstack, permanent_obstack;
|
||
extern struct obstack *current_obstack, *saveable_obstack;
|
||
|
||
extern double atof ();
|
||
|
||
extern char *get_directive_line (); /* In c-common.c */
|
||
|
||
/* Given a file name X, return the nondirectory portion.
|
||
Keep in mind that X can be computed more than once. */
|
||
#ifndef FILE_NAME_NONDIRECTORY
|
||
#define FILE_NAME_NONDIRECTORY(X) \
|
||
(rindex (X, '/') != 0 ? rindex (X, '/') + 1 : X)
|
||
#endif
|
||
|
||
extern char *index ();
|
||
extern char *rindex ();
|
||
|
||
void extract_interface_info ();
|
||
void yyerror ();
|
||
|
||
/* This obstack is needed to hold text. It is not safe to use
|
||
TOKEN_BUFFER because `check_newline' calls `yylex'. */
|
||
struct obstack inline_text_obstack;
|
||
static char *inline_text_firstobj;
|
||
|
||
/* This obstack is used to hold information about methods to be
|
||
synthesized. It should go away when synthesized methods are handled
|
||
properly (i.e. only when needed). */
|
||
struct obstack synth_obstack;
|
||
static char *synth_firstobj;
|
||
|
||
int end_of_file;
|
||
|
||
/* Pending language change.
|
||
Positive is push count, negative is pop count. */
|
||
int pending_lang_change = 0;
|
||
|
||
/* Wrap the current header file in extern "C". */
|
||
static int c_header_level = 0;
|
||
|
||
extern int first_token;
|
||
extern struct obstack token_obstack;
|
||
|
||
/* ??? Don't really know where this goes yet. */
|
||
#if 1
|
||
#include "input.c"
|
||
#else
|
||
extern void put_back (/* int */);
|
||
extern int input_redirected ();
|
||
extern void feed_input (/* char *, int, struct obstack * */);
|
||
#endif
|
||
|
||
/* Holds translations from TREE_CODEs to operator name strings,
|
||
i.e., opname_tab[PLUS_EXPR] == "+". */
|
||
char **opname_tab;
|
||
char **assignop_tab;
|
||
|
||
extern int yychar; /* the lookahead symbol */
|
||
extern YYSTYPE yylval; /* the semantic value of the */
|
||
/* lookahead symbol */
|
||
|
||
#if 0
|
||
YYLTYPE yylloc; /* location data for the lookahead */
|
||
/* symbol */
|
||
#endif
|
||
|
||
|
||
/* the declaration found for the last IDENTIFIER token read in.
|
||
yylex must look this up to detect typedefs, which get token type TYPENAME,
|
||
so it is left around in case the identifier is not a typedef but is
|
||
used in a context which makes it a reference to a variable. */
|
||
tree lastiddecl;
|
||
|
||
/* The elements of `ridpointers' are identifier nodes
|
||
for the reserved type names and storage classes.
|
||
It is indexed by a RID_... value. */
|
||
tree ridpointers[(int) RID_MAX];
|
||
|
||
/* We may keep statistics about how long which files took to compile. */
|
||
static int header_time, body_time;
|
||
static tree get_time_identifier ();
|
||
static tree filename_times;
|
||
static tree this_filename_time;
|
||
|
||
/* For implementing #pragma unit. */
|
||
tree current_unit_name;
|
||
tree current_unit_language;
|
||
|
||
/* Array for holding counts of the numbers of tokens seen. */
|
||
extern int *token_count;
|
||
|
||
/* Textual definition used for default functions. */
|
||
static void default_copy_constructor_body ();
|
||
static void default_assign_ref_body ();
|
||
|
||
/* Return something to represent absolute declarators containing a *.
|
||
TARGET is the absolute declarator that the * contains.
|
||
TYPE_QUALS is a list of modifiers such as const or volatile
|
||
to apply to the pointer type, represented as identifiers.
|
||
|
||
We return an INDIRECT_REF whose "contents" are TARGET
|
||
and whose type is the modifier list. */
|
||
|
||
tree
|
||
make_pointer_declarator (type_quals, target)
|
||
tree type_quals, target;
|
||
{
|
||
if (target && TREE_CODE (target) == IDENTIFIER_NODE
|
||
&& ANON_AGGRNAME_P (target))
|
||
error ("type name expected before `*'");
|
||
target = build_parse_node (INDIRECT_REF, target);
|
||
TREE_TYPE (target) = type_quals;
|
||
return target;
|
||
}
|
||
|
||
/* Return something to represent absolute declarators containing a &.
|
||
TARGET is the absolute declarator that the & contains.
|
||
TYPE_QUALS is a list of modifiers such as const or volatile
|
||
to apply to the reference type, represented as identifiers.
|
||
|
||
We return an ADDR_EXPR whose "contents" are TARGET
|
||
and whose type is the modifier list. */
|
||
|
||
tree
|
||
make_reference_declarator (type_quals, target)
|
||
tree type_quals, target;
|
||
{
|
||
if (target)
|
||
{
|
||
if (TREE_CODE (target) == ADDR_EXPR)
|
||
{
|
||
error ("cannot declare references to references");
|
||
return target;
|
||
}
|
||
if (TREE_CODE (target) == INDIRECT_REF)
|
||
{
|
||
error ("cannot declare pointers to references");
|
||
return target;
|
||
}
|
||
if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
|
||
error ("type name expected before `&'");
|
||
}
|
||
target = build_parse_node (ADDR_EXPR, target);
|
||
TREE_TYPE (target) = type_quals;
|
||
return target;
|
||
}
|
||
|
||
/* Build names and nodes for overloaded operators. */
|
||
|
||
tree ansi_opname[LAST_CPLUS_TREE_CODE];
|
||
tree ansi_assopname[LAST_CPLUS_TREE_CODE];
|
||
|
||
char *
|
||
operator_name_string (name)
|
||
tree name;
|
||
{
|
||
char *opname = IDENTIFIER_POINTER (name) + 2;
|
||
tree *opname_table;
|
||
int i, assign;
|
||
|
||
/* Works for builtin and user defined types. */
|
||
if (IDENTIFIER_GLOBAL_VALUE (name)
|
||
&& TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
|
||
return IDENTIFIER_POINTER (name);
|
||
|
||
if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
|
||
{
|
||
opname += 1;
|
||
assign = 1;
|
||
opname_table = ansi_assopname;
|
||
}
|
||
else
|
||
{
|
||
assign = 0;
|
||
opname_table = ansi_opname;
|
||
}
|
||
|
||
for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
|
||
{
|
||
if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
|
||
&& opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
|
||
break;
|
||
}
|
||
|
||
if (i == LAST_CPLUS_TREE_CODE)
|
||
return "<invalid operator>";
|
||
|
||
if (assign)
|
||
return assignop_tab[i];
|
||
else
|
||
return opname_tab[i];
|
||
}
|
||
|
||
int interface_only; /* whether or not current file is only for
|
||
interface definitions. */
|
||
int interface_unknown; /* whether or not we know this class
|
||
to behave according to #pragma interface. */
|
||
|
||
/* lexical analyzer */
|
||
|
||
/* File used for outputting assembler code. */
|
||
extern FILE *asm_out_file;
|
||
|
||
#ifndef WCHAR_TYPE_SIZE
|
||
#ifdef INT_TYPE_SIZE
|
||
#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
|
||
#else
|
||
#define WCHAR_TYPE_SIZE BITS_PER_WORD
|
||
#endif
|
||
#endif
|
||
|
||
/* Number of bytes in a wide character. */
|
||
#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
|
||
|
||
static int maxtoken; /* Current nominal length of token buffer. */
|
||
char *token_buffer; /* Pointer to token buffer.
|
||
Actual allocated length is maxtoken + 2. */
|
||
|
||
#include "hash.h"
|
||
|
||
int check_newline ();
|
||
|
||
/* Nonzero tells yylex to ignore \ in string constants. */
|
||
static int ignore_escape_flag = 0;
|
||
|
||
static int skip_white_space ();
|
||
|
||
static tree
|
||
get_time_identifier (name)
|
||
char *name;
|
||
{
|
||
tree time_identifier;
|
||
int len = strlen (name);
|
||
char *buf = (char *) alloca (len + 6);
|
||
strcpy (buf, "file ");
|
||
bcopy (name, buf+5, len);
|
||
buf[len+5] = '\0';
|
||
time_identifier = get_identifier (buf);
|
||
if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
|
||
{
|
||
push_obstacks_nochange ();
|
||
end_temporary_allocation ();
|
||
IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
|
||
IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
|
||
IDENTIFIER_GLOBAL_VALUE (time_identifier) = filename_times;
|
||
filename_times = time_identifier;
|
||
pop_obstacks ();
|
||
}
|
||
return time_identifier;
|
||
}
|
||
|
||
#ifdef __GNUC__
|
||
__inline
|
||
#endif
|
||
static int
|
||
my_get_run_time ()
|
||
{
|
||
int old_quiet_flag = quiet_flag;
|
||
int this_time;
|
||
quiet_flag = 0;
|
||
this_time = get_run_time ();
|
||
quiet_flag = old_quiet_flag;
|
||
return this_time;
|
||
}
|
||
|
||
/* Table indexed by tree code giving a string containing a character
|
||
classifying the tree code. Possibilities are
|
||
t, d, s, c, r, <, 1 and 2. See cp/tree.def for details. */
|
||
|
||
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
|
||
|
||
char *cplus_tree_code_type[] = {
|
||
"x",
|
||
#include "tree.def"
|
||
};
|
||
#undef DEFTREECODE
|
||
|
||
/* Table indexed by tree code giving number of expression
|
||
operands beyond the fixed part of the node structure.
|
||
Not used for types or decls. */
|
||
|
||
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
|
||
|
||
int cplus_tree_code_length[] = {
|
||
0,
|
||
#include "tree.def"
|
||
};
|
||
#undef DEFTREECODE
|
||
|
||
/* Names of tree components.
|
||
Used for printing out the tree and error messages. */
|
||
#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
|
||
|
||
char *cplus_tree_code_name[] = {
|
||
"@@dummy",
|
||
#include "tree.def"
|
||
};
|
||
#undef DEFTREECODE
|
||
|
||
/* toplev.c needs to call these. */
|
||
|
||
void
|
||
lang_init ()
|
||
{
|
||
/* the beginning of the file is a new line; check for # */
|
||
/* With luck, we discover the real source file's name from that
|
||
and put it in input_filename. */
|
||
put_back (check_newline ());
|
||
|
||
if (flag_cadillac)
|
||
cadillac_start ();
|
||
if (flag_gnu_xref) GNU_xref_begin (input_filename);
|
||
init_repo (input_filename);
|
||
}
|
||
|
||
void
|
||
lang_finish ()
|
||
{
|
||
extern int errorcount, sorrycount;
|
||
if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
|
||
}
|
||
|
||
char *
|
||
lang_identify ()
|
||
{
|
||
return "cplusplus";
|
||
}
|
||
|
||
void
|
||
init_filename_times ()
|
||
{
|
||
this_filename_time = get_time_identifier ("<top level>");
|
||
if (flag_detailed_statistics)
|
||
{
|
||
header_time = 0;
|
||
body_time = my_get_run_time ();
|
||
TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
|
||
}
|
||
}
|
||
|
||
/* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
|
||
Stuck this hack in to get the files open correctly; this is called
|
||
in place of init_lex if we are an unexec'd binary. */
|
||
void
|
||
reinit_lang_specific ()
|
||
{
|
||
init_filename_times ();
|
||
reinit_search_statistics ();
|
||
}
|
||
|
||
void
|
||
init_lex ()
|
||
{
|
||
extern char *(*decl_printable_name) ();
|
||
extern int flag_no_gnu_keywords;
|
||
extern int flag_operator_names;
|
||
|
||
int i;
|
||
|
||
/* Initialize the lookahead machinery. */
|
||
init_spew ();
|
||
|
||
/* Make identifier nodes long enough for the language-specific slots. */
|
||
set_identifier_size (sizeof (struct lang_identifier));
|
||
decl_printable_name = lang_printable_name;
|
||
|
||
init_cplus_expand ();
|
||
|
||
tree_code_type
|
||
= (char **) realloc (tree_code_type,
|
||
sizeof (char *) * LAST_CPLUS_TREE_CODE);
|
||
tree_code_length
|
||
= (int *) realloc (tree_code_length,
|
||
sizeof (int) * LAST_CPLUS_TREE_CODE);
|
||
tree_code_name
|
||
= (char **) realloc (tree_code_name,
|
||
sizeof (char *) * LAST_CPLUS_TREE_CODE);
|
||
bcopy ((char *)cplus_tree_code_type,
|
||
(char *)(tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE),
|
||
(LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
|
||
bcopy ((char *)cplus_tree_code_length,
|
||
(char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
|
||
(LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
|
||
bcopy ((char *)cplus_tree_code_name,
|
||
(char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
|
||
(LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
|
||
|
||
opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
|
||
bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
|
||
assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
|
||
bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
|
||
|
||
ansi_opname[0] = get_identifier ("<invalid operator>");
|
||
for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
|
||
{
|
||
ansi_opname[i] = ansi_opname[0];
|
||
ansi_assopname[i] = ansi_opname[0];
|
||
}
|
||
|
||
ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
|
||
ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
|
||
ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
|
||
ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
|
||
ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
|
||
ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
|
||
ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
|
||
ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
|
||
ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
|
||
ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
|
||
ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
|
||
ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
|
||
ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
|
||
ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
|
||
ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
|
||
ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
|
||
ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
|
||
ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
|
||
ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
|
||
ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
|
||
ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
|
||
ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
|
||
ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
|
||
ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
|
||
ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
|
||
ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
|
||
ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
|
||
ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
|
||
ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
|
||
ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
|
||
ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
|
||
ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
|
||
ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
|
||
ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
|
||
ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
|
||
ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
|
||
ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
|
||
ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
|
||
ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
|
||
ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
|
||
ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
|
||
ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
|
||
ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
|
||
ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
|
||
ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
|
||
ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
|
||
ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
|
||
ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
|
||
ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
|
||
ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
|
||
ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
|
||
ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
|
||
IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
|
||
ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
|
||
ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
|
||
ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
|
||
ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
|
||
ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
|
||
ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
|
||
ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
|
||
ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
|
||
ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
|
||
ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
|
||
ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
|
||
ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
|
||
ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
|
||
|
||
/* This is not true: these operators are not defined in ANSI,
|
||
but we need them anyway. */
|
||
ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
|
||
ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
|
||
ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
|
||
ansi_opname[(int) METHOD_CALL_EXPR] = get_identifier ("__wr");
|
||
IDENTIFIER_OPNAME_P (ansi_opname[(int) METHOD_CALL_EXPR]) = 1;
|
||
|
||
init_method ();
|
||
init_error ();
|
||
gcc_obstack_init (&inline_text_obstack);
|
||
inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
|
||
gcc_obstack_init (&synth_obstack);
|
||
synth_firstobj = (char *) obstack_alloc (&synth_obstack, 0);
|
||
|
||
/* Start it at 0, because check_newline is called at the very beginning
|
||
and will increment it to 1. */
|
||
lineno = 0;
|
||
input_filename = "<internal>";
|
||
current_function_decl = NULL;
|
||
|
||
maxtoken = 40;
|
||
token_buffer = (char *) xmalloc (maxtoken + 2);
|
||
|
||
ridpointers[(int) RID_INT] = get_identifier ("int");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
|
||
ridpointers[(int) RID_BOOL] = get_identifier ("bool");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BOOL],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_BOOL]));
|
||
ridpointers[(int) RID_CHAR] = get_identifier ("char");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
|
||
ridpointers[(int) RID_VOID] = get_identifier ("void");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
|
||
ridpointers[(int) RID_FLOAT] = get_identifier ("float");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
|
||
ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
|
||
ridpointers[(int) RID_SHORT] = get_identifier ("short");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
|
||
ridpointers[(int) RID_LONG] = get_identifier ("long");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
|
||
ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
|
||
ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
|
||
ridpointers[(int) RID_INLINE] = get_identifier ("inline");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
|
||
ridpointers[(int) RID_CONST] = get_identifier ("const");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
|
||
ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
|
||
ridpointers[(int) RID_AUTO] = get_identifier ("auto");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
|
||
ridpointers[(int) RID_STATIC] = get_identifier ("static");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
|
||
ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
|
||
ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
|
||
ridpointers[(int) RID_REGISTER] = get_identifier ("register");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
|
||
|
||
/* C++ extensions. These are probably not correctly named. */
|
||
ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
|
||
class_type_node = build_int_2 (class_type, 0);
|
||
TREE_TYPE (class_type_node) = class_type_node;
|
||
ridpointers[(int) RID_CLASS] = class_type_node;
|
||
|
||
record_type_node = build_int_2 (record_type, 0);
|
||
TREE_TYPE (record_type_node) = record_type_node;
|
||
ridpointers[(int) RID_RECORD] = record_type_node;
|
||
|
||
union_type_node = build_int_2 (union_type, 0);
|
||
TREE_TYPE (union_type_node) = union_type_node;
|
||
ridpointers[(int) RID_UNION] = union_type_node;
|
||
|
||
enum_type_node = build_int_2 (enum_type, 0);
|
||
TREE_TYPE (enum_type_node) = enum_type_node;
|
||
ridpointers[(int) RID_ENUM] = enum_type_node;
|
||
|
||
ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
|
||
ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
|
||
ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
|
||
|
||
ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
|
||
ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
|
||
ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
|
||
ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TEMPLATE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_TEMPLATE]));
|
||
/* This is for ANSI C++. */
|
||
ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
|
||
SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
|
||
build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
|
||
|
||
/* Signature handling extensions. */
|
||
signature_type_node = build_int_2 (signature_type, 0);
|
||
TREE_TYPE (signature_type_node) = signature_type_node;
|
||
ridpointers[(int) RID_SIGNATURE] = signature_type_node;
|
||
|
||
opname_tab[(int) COMPONENT_REF] = "->";
|
||
opname_tab[(int) MEMBER_REF] = "->*";
|
||
opname_tab[(int) METHOD_CALL_EXPR] = "->()";
|
||
opname_tab[(int) INDIRECT_REF] = "(unary *)";
|
||
opname_tab[(int) ARRAY_REF] = "[]";
|
||
opname_tab[(int) MODIFY_EXPR] = "=";
|
||
opname_tab[(int) NEW_EXPR] = "new";
|
||
opname_tab[(int) DELETE_EXPR] = "delete";
|
||
opname_tab[(int) VEC_NEW_EXPR] = "new []";
|
||
opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
|
||
opname_tab[(int) COND_EXPR] = "... ? ... : ...";
|
||
opname_tab[(int) CALL_EXPR] = "()";
|
||
opname_tab[(int) PLUS_EXPR] = "+";
|
||
opname_tab[(int) MINUS_EXPR] = "-";
|
||
opname_tab[(int) MULT_EXPR] = "*";
|
||
opname_tab[(int) TRUNC_DIV_EXPR] = "/";
|
||
opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
|
||
opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
|
||
opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
|
||
opname_tab[(int) TRUNC_MOD_EXPR] = "%";
|
||
opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
|
||
opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
|
||
opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
|
||
opname_tab[(int) NEGATE_EXPR] = "-";
|
||
opname_tab[(int) MIN_EXPR] = "<?";
|
||
opname_tab[(int) MAX_EXPR] = ">?";
|
||
opname_tab[(int) ABS_EXPR] = "abs";
|
||
opname_tab[(int) FFS_EXPR] = "ffs";
|
||
opname_tab[(int) LSHIFT_EXPR] = "<<";
|
||
opname_tab[(int) RSHIFT_EXPR] = ">>";
|
||
opname_tab[(int) BIT_IOR_EXPR] = "|";
|
||
opname_tab[(int) BIT_XOR_EXPR] = "^";
|
||
opname_tab[(int) BIT_AND_EXPR] = "&";
|
||
opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
|
||
opname_tab[(int) BIT_NOT_EXPR] = "~";
|
||
opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
|
||
opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
|
||
opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
|
||
opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
|
||
opname_tab[(int) TRUTH_NOT_EXPR] = "!";
|
||
opname_tab[(int) LT_EXPR] = "<";
|
||
opname_tab[(int) LE_EXPR] = "<=";
|
||
opname_tab[(int) GT_EXPR] = ">";
|
||
opname_tab[(int) GE_EXPR] = ">=";
|
||
opname_tab[(int) EQ_EXPR] = "==";
|
||
opname_tab[(int) NE_EXPR] = "!=";
|
||
opname_tab[(int) IN_EXPR] = "in";
|
||
opname_tab[(int) RANGE_EXPR] = "..";
|
||
opname_tab[(int) CONVERT_EXPR] = "(unary +)";
|
||
opname_tab[(int) ADDR_EXPR] = "(unary &)";
|
||
opname_tab[(int) PREDECREMENT_EXPR] = "--";
|
||
opname_tab[(int) PREINCREMENT_EXPR] = "++";
|
||
opname_tab[(int) POSTDECREMENT_EXPR] = "--";
|
||
opname_tab[(int) POSTINCREMENT_EXPR] = "++";
|
||
opname_tab[(int) COMPOUND_EXPR] = ",";
|
||
|
||
assignop_tab[(int) NOP_EXPR] = "=";
|
||
assignop_tab[(int) PLUS_EXPR] = "+=";
|
||
assignop_tab[(int) CONVERT_EXPR] = "+=";
|
||
assignop_tab[(int) MINUS_EXPR] = "-=";
|
||
assignop_tab[(int) NEGATE_EXPR] = "-=";
|
||
assignop_tab[(int) MULT_EXPR] = "*=";
|
||
assignop_tab[(int) INDIRECT_REF] = "*=";
|
||
assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
|
||
assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
|
||
assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
|
||
assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
|
||
assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
|
||
assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
|
||
assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
|
||
assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
|
||
assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
|
||
assignop_tab[(int) MIN_EXPR] = "<?=";
|
||
assignop_tab[(int) MAX_EXPR] = ">?=";
|
||
assignop_tab[(int) LSHIFT_EXPR] = "<<=";
|
||
assignop_tab[(int) RSHIFT_EXPR] = ">>=";
|
||
assignop_tab[(int) BIT_IOR_EXPR] = "|=";
|
||
assignop_tab[(int) BIT_XOR_EXPR] = "^=";
|
||
assignop_tab[(int) BIT_AND_EXPR] = "&=";
|
||
assignop_tab[(int) ADDR_EXPR] = "&=";
|
||
|
||
init_filename_times ();
|
||
|
||
/* Some options inhibit certain reserved words.
|
||
Clear those words out of the hash table so they won't be recognized. */
|
||
#define UNSET_RESERVED_WORD(STRING) \
|
||
do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
|
||
if (s) s->name = ""; } while (0)
|
||
|
||
#if 0
|
||
/* let's parse things, and if they use it, then give them an error. */
|
||
if (!flag_handle_exceptions)
|
||
{
|
||
UNSET_RESERVED_WORD ("throw");
|
||
UNSET_RESERVED_WORD ("try");
|
||
UNSET_RESERVED_WORD ("catch");
|
||
}
|
||
#endif
|
||
|
||
if (! (flag_gc || flag_rtti) || flag_no_gnu_keywords)
|
||
{
|
||
UNSET_RESERVED_WORD ("classof");
|
||
UNSET_RESERVED_WORD ("headof");
|
||
}
|
||
if (! flag_handle_signatures || flag_no_gnu_keywords)
|
||
{
|
||
/* Easiest way to not recognize signature
|
||
handling extensions... */
|
||
UNSET_RESERVED_WORD ("signature");
|
||
UNSET_RESERVED_WORD ("sigof");
|
||
}
|
||
if (flag_no_asm || flag_no_gnu_keywords)
|
||
UNSET_RESERVED_WORD ("typeof");
|
||
if (! flag_operator_names)
|
||
{
|
||
/* These are new ANSI keywords that may break code. */
|
||
UNSET_RESERVED_WORD ("and");
|
||
UNSET_RESERVED_WORD ("and_eq");
|
||
UNSET_RESERVED_WORD ("bitand");
|
||
UNSET_RESERVED_WORD ("bitor");
|
||
UNSET_RESERVED_WORD ("compl");
|
||
UNSET_RESERVED_WORD ("not");
|
||
UNSET_RESERVED_WORD ("not_eq");
|
||
UNSET_RESERVED_WORD ("or");
|
||
UNSET_RESERVED_WORD ("or_eq");
|
||
UNSET_RESERVED_WORD ("xor");
|
||
UNSET_RESERVED_WORD ("xor_eq");
|
||
}
|
||
if (! flag_traditional)
|
||
UNSET_RESERVED_WORD ("overload");
|
||
|
||
token_count = init_parse ();
|
||
interface_unknown = 1;
|
||
}
|
||
|
||
void
|
||
reinit_parse_for_function ()
|
||
{
|
||
current_base_init_list = NULL_TREE;
|
||
current_member_init_list = NULL_TREE;
|
||
}
|
||
|
||
#ifdef __GNUC__
|
||
__inline
|
||
#endif
|
||
void
|
||
yyprint (file, yychar, yylval)
|
||
FILE *file;
|
||
int yychar;
|
||
YYSTYPE yylval;
|
||
{
|
||
tree t;
|
||
switch (yychar)
|
||
{
|
||
case IDENTIFIER:
|
||
case TYPENAME:
|
||
case TYPESPEC:
|
||
case PTYPENAME:
|
||
case IDENTIFIER_DEFN:
|
||
case TYPENAME_DEFN:
|
||
case PTYPENAME_DEFN:
|
||
case TYPENAME_ELLIPSIS:
|
||
case SCSPEC:
|
||
case PRE_PARSED_CLASS_DECL:
|
||
t = yylval.ttype;
|
||
my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
|
||
if (IDENTIFIER_POINTER (t))
|
||
fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
|
||
break;
|
||
case AGGR:
|
||
if (yylval.ttype == class_type_node)
|
||
fprintf (file, " `class'");
|
||
else if (yylval.ttype == record_type_node)
|
||
fprintf (file, " `struct'");
|
||
else if (yylval.ttype == union_type_node)
|
||
fprintf (file, " `union'");
|
||
else if (yylval.ttype == enum_type_node)
|
||
fprintf (file, " `enum'");
|
||
else if (yylval.ttype == signature_type_node)
|
||
fprintf (file, " `signature'");
|
||
else
|
||
my_friendly_abort (80);
|
||
break;
|
||
}
|
||
}
|
||
|
||
static int *reduce_count;
|
||
int *token_count;
|
||
|
||
#define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
|
||
#define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
|
||
|
||
int *
|
||
init_parse ()
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
|
||
bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
|
||
reduce_count += 1;
|
||
token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
|
||
bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
|
||
token_count += 1;
|
||
#endif
|
||
return token_count;
|
||
}
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
void
|
||
yyhook (yyn)
|
||
int yyn;
|
||
{
|
||
reduce_count[yyn] += 1;
|
||
}
|
||
|
||
static int
|
||
reduce_cmp (p, q)
|
||
int *p, *q;
|
||
{
|
||
return reduce_count[*q] - reduce_count[*p];
|
||
}
|
||
|
||
static int
|
||
token_cmp (p, q)
|
||
int *p, *q;
|
||
{
|
||
return token_count[*q] - token_count[*p];
|
||
}
|
||
#endif
|
||
|
||
void
|
||
print_parse_statistics ()
|
||
{
|
||
#ifdef GATHER_STATISTICS
|
||
#if YYDEBUG != 0
|
||
int i;
|
||
int maxlen = REDUCE_LENGTH;
|
||
unsigned *sorted;
|
||
|
||
if (reduce_count[-1] == 0)
|
||
return;
|
||
|
||
if (TOKEN_LENGTH > REDUCE_LENGTH)
|
||
maxlen = TOKEN_LENGTH;
|
||
sorted = (unsigned *) alloca (sizeof (int) * maxlen);
|
||
|
||
for (i = 0; i < TOKEN_LENGTH; i++)
|
||
sorted[i] = i;
|
||
qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
|
||
for (i = 0; i < TOKEN_LENGTH; i++)
|
||
{
|
||
int index = sorted[i];
|
||
if (token_count[index] == 0)
|
||
break;
|
||
if (token_count[index] < token_count[-1])
|
||
break;
|
||
fprintf (stderr, "token %d, `%s', count = %d\n",
|
||
index, yytname[YYTRANSLATE (index)], token_count[index]);
|
||
}
|
||
fprintf (stderr, "\n");
|
||
for (i = 0; i < REDUCE_LENGTH; i++)
|
||
sorted[i] = i;
|
||
qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
|
||
for (i = 0; i < REDUCE_LENGTH; i++)
|
||
{
|
||
int index = sorted[i];
|
||
if (reduce_count[index] == 0)
|
||
break;
|
||
if (reduce_count[index] < reduce_count[-1])
|
||
break;
|
||
fprintf (stderr, "rule %d, line %d, count = %d\n",
|
||
index, yyrline[index], reduce_count[index]);
|
||
}
|
||
fprintf (stderr, "\n");
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
/* Sets the value of the 'yydebug' variable to VALUE.
|
||
This is a function so we don't have to have YYDEBUG defined
|
||
in order to build the compiler. */
|
||
void
|
||
set_yydebug (value)
|
||
int value;
|
||
{
|
||
#if YYDEBUG != 0
|
||
extern int yydebug;
|
||
yydebug = value;
|
||
#else
|
||
warning ("YYDEBUG not defined.");
|
||
#endif
|
||
}
|
||
|
||
|
||
/* Functions and data structures for #pragma interface.
|
||
|
||
`#pragma implementation' means that the main file being compiled
|
||
is considered to implement (provide) the classes that appear in
|
||
its main body. I.e., if this is file "foo.cc", and class `bar'
|
||
is defined in "foo.cc", then we say that "foo.cc implements bar".
|
||
|
||
All main input files "implement" themselves automagically.
|
||
|
||
`#pragma interface' means that unless this file (of the form "foo.h"
|
||
is not presently being included by file "foo.cc", the
|
||
CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
|
||
of the vtables nor any of the inline functions defined in foo.h
|
||
will ever be output.
|
||
|
||
There are cases when we want to link files such as "defs.h" and
|
||
"main.cc". In this case, we give "defs.h" a `#pragma interface',
|
||
and "main.cc" has `#pragma implementation "defs.h"'. */
|
||
|
||
struct impl_files
|
||
{
|
||
char *filename;
|
||
struct impl_files *next;
|
||
};
|
||
|
||
static struct impl_files *impl_file_chain;
|
||
|
||
/* Helper function to load global variables with interface
|
||
information. */
|
||
void
|
||
extract_interface_info ()
|
||
{
|
||
tree fileinfo = 0;
|
||
|
||
if (flag_alt_external_templates)
|
||
{
|
||
struct tinst_level *til = tinst_for_decl ();
|
||
|
||
if (til)
|
||
fileinfo = get_time_identifier (til->file);
|
||
}
|
||
if (!fileinfo)
|
||
fileinfo = get_time_identifier (input_filename);
|
||
fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
|
||
interface_only = TREE_INT_CST_LOW (fileinfo);
|
||
if (!processing_template_defn || flag_external_templates)
|
||
interface_unknown = TREE_INT_CST_HIGH (fileinfo);
|
||
}
|
||
|
||
/* Return nonzero if S is not considered part of an
|
||
INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
|
||
static int
|
||
interface_strcmp (s)
|
||
char *s;
|
||
{
|
||
/* Set the interface/implementation bits for this scope. */
|
||
struct impl_files *ifiles;
|
||
char *s1;
|
||
|
||
for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
|
||
{
|
||
char *t1 = ifiles->filename;
|
||
s1 = s;
|
||
|
||
if (*s1 != *t1 || *s1 == 0)
|
||
continue;
|
||
|
||
while (*s1 == *t1 && *s1 != 0)
|
||
s1++, t1++;
|
||
|
||
/* A match. */
|
||
if (*s1 == *t1)
|
||
return 0;
|
||
|
||
/* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
|
||
if (index (s1, '.') || index (t1, '.'))
|
||
continue;
|
||
|
||
if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
|
||
continue;
|
||
|
||
/* A match. */
|
||
return 0;
|
||
}
|
||
|
||
/* No matches. */
|
||
return 1;
|
||
}
|
||
|
||
void
|
||
set_typedecl_interface_info (prev, vars)
|
||
tree prev, vars;
|
||
{
|
||
tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
|
||
tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
|
||
tree type = TREE_TYPE (vars);
|
||
|
||
CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
|
||
= interface_strcmp (FILE_NAME_NONDIRECTORY (DECL_SOURCE_FILE (vars)));
|
||
}
|
||
|
||
void
|
||
set_vardecl_interface_info (prev, vars)
|
||
tree prev, vars;
|
||
{
|
||
tree type = DECL_CONTEXT (vars);
|
||
|
||
if (CLASSTYPE_INTERFACE_KNOWN (type))
|
||
{
|
||
if (CLASSTYPE_INTERFACE_ONLY (type))
|
||
set_typedecl_interface_info (prev, TYPE_NAME (type));
|
||
else
|
||
CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
|
||
DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
|
||
TREE_PUBLIC (vars) = 1;
|
||
}
|
||
}
|
||
|
||
/* Called from the top level: if there are any pending inlines to
|
||
do, set up to process them now. This function sets up the first function
|
||
to be parsed; after it has been, the rule for fndef in parse.y will
|
||
call process_next_inline to start working on the next one. */
|
||
void
|
||
do_pending_inlines ()
|
||
{
|
||
struct pending_inline *t;
|
||
|
||
/* Oops, we're still dealing with the last batch. */
|
||
if (yychar == PRE_PARSED_FUNCTION_DECL)
|
||
return;
|
||
|
||
/* Reverse the pending inline functions, since
|
||
they were cons'd instead of appended. */
|
||
{
|
||
struct pending_inline *prev = 0, *tail, *bottom = 0;
|
||
t = pending_inlines;
|
||
pending_inlines = 0;
|
||
|
||
for (; t; t = tail)
|
||
{
|
||
tail = t->next;
|
||
t->next = prev;
|
||
t->deja_vu = 1;
|
||
prev = t;
|
||
}
|
||
|
||
/* This kludge should go away when synthesized methods are handled
|
||
properly, i.e. only when needed. */
|
||
for (t = prev; t; t = t->next)
|
||
{
|
||
if (t->lineno <= 0)
|
||
{
|
||
tree f = t->fndecl;
|
||
DECL_PENDING_INLINE_INFO (f) = 0;
|
||
interface_unknown = t->interface == 1;
|
||
interface_only = t->interface == 0;
|
||
synthesize_method (f);
|
||
if (tail)
|
||
tail->next = t->next;
|
||
else
|
||
prev = t->next;
|
||
if (! bottom)
|
||
bottom = t;
|
||
}
|
||
else
|
||
tail = t;
|
||
}
|
||
if (bottom)
|
||
{
|
||
obstack_free (&synth_obstack, bottom);
|
||
extract_interface_info ();
|
||
}
|
||
t = prev;
|
||
}
|
||
|
||
if (t == 0)
|
||
return;
|
||
|
||
/* Now start processing the first inline function. */
|
||
my_friendly_assert ((t->parm_vec == NULL_TREE) == (t->bindings == NULL_TREE),
|
||
226);
|
||
if (t->parm_vec)
|
||
push_template_decls (t->parm_vec, t->bindings, 0);
|
||
if (t->len > 0)
|
||
{
|
||
feed_input (t->buf, t->len, t->can_free ? &inline_text_obstack : 0);
|
||
lineno = t->lineno;
|
||
#if 0
|
||
if (input_filename != t->filename)
|
||
{
|
||
input_filename = t->filename;
|
||
/* Get interface/implementation back in sync. */
|
||
extract_interface_info ();
|
||
}
|
||
#else
|
||
input_filename = t->filename;
|
||
interface_unknown = t->interface == 1;
|
||
interface_only = t->interface == 0;
|
||
#endif
|
||
yychar = PRE_PARSED_FUNCTION_DECL;
|
||
}
|
||
/* Pass back a handle on the rest of the inline functions, so that they
|
||
can be processed later. */
|
||
yylval.ttype = build_tree_list ((tree) t, t->fndecl);
|
||
#if 0
|
||
if (flag_default_inline && t->fndecl
|
||
/* If we're working from a template, don't change
|
||
the `inline' state. */
|
||
&& t->parm_vec == NULL_TREE)
|
||
DECL_INLINE (t->fndecl) = 1;
|
||
#endif
|
||
DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
|
||
}
|
||
|
||
extern struct pending_input *to_be_restored;
|
||
static int nextchar = -1;
|
||
|
||
/* Called from the fndecl rule in the parser when the function just parsed
|
||
was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
|
||
do_pending_inlines). */
|
||
void
|
||
process_next_inline (t)
|
||
tree t;
|
||
{
|
||
struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
|
||
my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
|
||
227);
|
||
if (i->parm_vec)
|
||
pop_template_decls (i->parm_vec, i->bindings, 0);
|
||
i = i->next;
|
||
if (yychar == YYEMPTY)
|
||
yychar = yylex ();
|
||
if (yychar != END_OF_SAVED_INPUT)
|
||
{
|
||
error ("parse error at end of saved function text");
|
||
/* restore_pending_input will abort unless yychar is either
|
||
* END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
|
||
* hosed, feed back YYEMPTY.
|
||
* We also need to discard nextchar, since that may have gotten
|
||
* set as well.
|
||
*/
|
||
nextchar = -1;
|
||
}
|
||
yychar = YYEMPTY;
|
||
if (to_be_restored == 0)
|
||
my_friendly_abort (123);
|
||
restore_pending_input (to_be_restored);
|
||
to_be_restored = 0;
|
||
if (i && i->fndecl != NULL_TREE)
|
||
{
|
||
my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
|
||
228);
|
||
if (i->parm_vec)
|
||
push_template_decls (i->parm_vec, i->bindings, 0);
|
||
feed_input (i->buf, i->len, i->can_free ? &inline_text_obstack : 0);
|
||
lineno = i->lineno;
|
||
input_filename = i->filename;
|
||
yychar = PRE_PARSED_FUNCTION_DECL;
|
||
yylval.ttype = build_tree_list ((tree) i, i->fndecl);
|
||
#if 0
|
||
if (flag_default_inline
|
||
/* If we're working from a template, don't change
|
||
the `inline' state. */
|
||
&& i->parm_vec == NULL_TREE)
|
||
DECL_INLINE (i->fndecl) = 1;
|
||
#endif
|
||
DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
|
||
}
|
||
if (i)
|
||
{
|
||
interface_unknown = i->interface == 1;
|
||
interface_only = i->interface == 0;
|
||
}
|
||
else
|
||
extract_interface_info ();
|
||
}
|
||
|
||
/* Since inline methods can refer to text which has not yet been seen,
|
||
we store the text of the method in a structure which is placed in the
|
||
DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
|
||
After parsing the body of the class definition, the FUNCTION_DECL's are
|
||
scanned to see which ones have this field set. Those are then digested
|
||
one at a time.
|
||
|
||
This function's FUNCTION_DECL will have a bit set in its common so
|
||
that we know to watch out for it. */
|
||
|
||
static void
|
||
consume_string (this_obstack, matching_char)
|
||
register struct obstack *this_obstack;
|
||
int matching_char;
|
||
{
|
||
register int c;
|
||
int starting_lineno = lineno;
|
||
do
|
||
{
|
||
c = getch ();
|
||
if (c == EOF)
|
||
{
|
||
int save_lineno = lineno;
|
||
lineno = starting_lineno;
|
||
if (matching_char == '"')
|
||
error ("end of file encountered inside string constant");
|
||
else
|
||
error ("end of file encountered inside character constant");
|
||
lineno = save_lineno;
|
||
return;
|
||
}
|
||
if (c == '\\')
|
||
{
|
||
obstack_1grow (this_obstack, c);
|
||
c = getch ();
|
||
obstack_1grow (this_obstack, c);
|
||
|
||
/* Make sure we continue the loop */
|
||
c = 0;
|
||
continue;
|
||
}
|
||
if (c == '\n')
|
||
{
|
||
if (pedantic)
|
||
pedwarn ("ANSI C++ forbids newline in string constant");
|
||
lineno++;
|
||
}
|
||
obstack_1grow (this_obstack, c);
|
||
}
|
||
while (c != matching_char);
|
||
}
|
||
|
||
static int nextyychar = YYEMPTY;
|
||
static YYSTYPE nextyylval;
|
||
|
||
struct pending_input {
|
||
int nextchar, yychar, nextyychar, eof;
|
||
YYSTYPE yylval, nextyylval;
|
||
struct obstack token_obstack;
|
||
int first_token;
|
||
};
|
||
|
||
struct pending_input *
|
||
save_pending_input ()
|
||
{
|
||
struct pending_input *p;
|
||
p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
|
||
p->nextchar = nextchar;
|
||
p->yychar = yychar;
|
||
p->nextyychar = nextyychar;
|
||
p->yylval = yylval;
|
||
p->nextyylval = nextyylval;
|
||
p->eof = end_of_file;
|
||
yychar = nextyychar = YYEMPTY;
|
||
nextchar = -1;
|
||
p->first_token = first_token;
|
||
p->token_obstack = token_obstack;
|
||
|
||
first_token = 0;
|
||
gcc_obstack_init (&token_obstack);
|
||
end_of_file = 0;
|
||
return p;
|
||
}
|
||
|
||
void
|
||
restore_pending_input (p)
|
||
struct pending_input *p;
|
||
{
|
||
my_friendly_assert (nextchar == -1, 229);
|
||
nextchar = p->nextchar;
|
||
my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
|
||
yychar = p->yychar;
|
||
my_friendly_assert (nextyychar == YYEMPTY, 231);
|
||
nextyychar = p->nextyychar;
|
||
yylval = p->yylval;
|
||
nextyylval = p->nextyylval;
|
||
first_token = p->first_token;
|
||
obstack_free (&token_obstack, (char *) 0);
|
||
token_obstack = p->token_obstack;
|
||
end_of_file = p->eof;
|
||
free (p);
|
||
}
|
||
|
||
/* Return next non-whitespace input character, which may come
|
||
from `finput', or from `nextchar'. */
|
||
static int
|
||
yynextch ()
|
||
{
|
||
int c;
|
||
|
||
if (nextchar >= 0)
|
||
{
|
||
c = nextchar;
|
||
nextchar = -1;
|
||
}
|
||
else c = getch ();
|
||
return skip_white_space (c);
|
||
}
|
||
|
||
/* Unget character CH from the input stream.
|
||
If RESCAN is non-zero, then we want to `see' this
|
||
character as the next input token. */
|
||
void
|
||
yyungetc (ch, rescan)
|
||
int ch;
|
||
int rescan;
|
||
{
|
||
/* Unget a character from the input stream. */
|
||
if (yychar == YYEMPTY || rescan == 0)
|
||
{
|
||
if (nextchar >= 0)
|
||
put_back (nextchar);
|
||
nextchar = ch;
|
||
}
|
||
else
|
||
{
|
||
my_friendly_assert (nextyychar == YYEMPTY, 232);
|
||
nextyychar = yychar;
|
||
nextyylval = yylval;
|
||
yychar = ch;
|
||
}
|
||
}
|
||
|
||
/* This function stores away the text for an inline function that should
|
||
be processed later. It decides how much later, and may need to move
|
||
the info between obstacks; therefore, the caller should not refer to
|
||
the T parameter after calling this function.
|
||
|
||
This function also stores the list of template-parameter bindings that
|
||
will be needed for expanding the template, if any. */
|
||
|
||
static void
|
||
store_pending_inline (decl, t)
|
||
tree decl;
|
||
struct pending_inline *t;
|
||
{
|
||
extern int processing_template_defn;
|
||
int delay_to_eof = 0;
|
||
struct pending_inline **inlines;
|
||
|
||
t->fndecl = decl;
|
||
/* Default: compile right away, and no extra bindings are needed. */
|
||
t->parm_vec = t->bindings = 0;
|
||
if (processing_template_defn)
|
||
{
|
||
tree type = current_class_type;
|
||
/* Assumption: In this (possibly) nested class sequence, only
|
||
one name will have template parms. */
|
||
while (type && TREE_CODE_CLASS (TREE_CODE (type)) == 't')
|
||
{
|
||
tree decl = TYPE_NAME (type);
|
||
tree tmpl = IDENTIFIER_TEMPLATE (DECL_NAME (decl));
|
||
if (tmpl)
|
||
{
|
||
t->parm_vec = DECL_TEMPLATE_INFO (TREE_PURPOSE (tmpl))->parm_vec;
|
||
t->bindings = TREE_VALUE (tmpl);
|
||
}
|
||
type = DECL_CONTEXT (decl);
|
||
}
|
||
if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
|
||
|| TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
|
||
{
|
||
if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
|
||
my_friendly_assert (TYPE_MAX_VALUE (TREE_TYPE (decl)) == current_class_type,
|
||
233);
|
||
|
||
/* Inline functions can be compiled immediately. Other functions
|
||
will be output separately, so if we're in interface-only mode,
|
||
punt them now, or output them now if we're doing implementations
|
||
and we know no overrides will exist. Otherwise, we delay until
|
||
end-of-file, to see if the definition is really required. */
|
||
if (DECL_THIS_INLINE (decl))
|
||
/* delay_to_eof == 0 */;
|
||
else if (current_class_type && !interface_unknown)
|
||
{
|
||
if (interface_only)
|
||
{
|
||
#if 0
|
||
print_node_brief (stderr, "\ndiscarding text for ", decl, 0);
|
||
#endif
|
||
if (t->can_free)
|
||
obstack_free (&inline_text_obstack, t->buf);
|
||
DECL_PENDING_INLINE_INFO (decl) = 0;
|
||
return;
|
||
}
|
||
}
|
||
/* Don't delay the processing of virtual functions. */
|
||
else if (DECL_VINDEX (decl) == NULL_TREE)
|
||
delay_to_eof = 1;
|
||
}
|
||
else
|
||
my_friendly_abort (58);
|
||
}
|
||
|
||
if (delay_to_eof)
|
||
{
|
||
extern struct pending_inline *pending_template_expansions;
|
||
|
||
if (t->can_free)
|
||
{
|
||
char *free_to = t->buf;
|
||
t->buf = (char *) obstack_copy (&permanent_obstack, t->buf,
|
||
t->len + 1);
|
||
t = (struct pending_inline *) obstack_copy (&permanent_obstack,
|
||
(char *)t, sizeof (*t));
|
||
obstack_free (&inline_text_obstack, free_to);
|
||
}
|
||
inlines = &pending_template_expansions;
|
||
t->can_free = 0;
|
||
}
|
||
else
|
||
{
|
||
inlines = &pending_inlines;
|
||
DECL_PENDING_INLINE_INFO (decl) = t;
|
||
}
|
||
|
||
/* Because we use obstacks, we must process these in precise order. */
|
||
t->next = *inlines;
|
||
*inlines = t;
|
||
}
|
||
|
||
void reinit_parse_for_block ();
|
||
|
||
void
|
||
reinit_parse_for_method (yychar, decl)
|
||
int yychar;
|
||
tree decl;
|
||
{
|
||
int len;
|
||
int starting_lineno = lineno;
|
||
char *starting_filename = input_filename;
|
||
|
||
reinit_parse_for_block (yychar, &inline_text_obstack, 0);
|
||
|
||
len = obstack_object_size (&inline_text_obstack);
|
||
current_base_init_list = NULL_TREE;
|
||
current_member_init_list = NULL_TREE;
|
||
if (decl == void_type_node
|
||
|| (current_class_type && TYPE_REDEFINED (current_class_type)))
|
||
{
|
||
/* Happens when we get two declarations of the same
|
||
function in the same scope. */
|
||
char *buf = obstack_finish (&inline_text_obstack);
|
||
obstack_free (&inline_text_obstack, buf);
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
struct pending_inline *t;
|
||
char *buf = obstack_finish (&inline_text_obstack);
|
||
|
||
t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
|
||
sizeof (struct pending_inline));
|
||
t->lineno = starting_lineno;
|
||
t->filename = starting_filename;
|
||
t->token = YYEMPTY;
|
||
t->token_value = 0;
|
||
t->buf = buf;
|
||
t->len = len;
|
||
t->can_free = 1;
|
||
t->deja_vu = 0;
|
||
if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
|
||
warn_if_unknown_interface (decl);
|
||
t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
|
||
store_pending_inline (decl, t);
|
||
}
|
||
}
|
||
|
||
/* Consume a block -- actually, a method or template definition beginning
|
||
with `:' or `{' -- and save it away on the specified obstack.
|
||
|
||
Argument IS_TEMPLATE indicates which set of error messages should be
|
||
output if something goes wrong. This should really be cleaned up somehow,
|
||
without loss of clarity. */
|
||
void
|
||
reinit_parse_for_block (pyychar, obstackp, is_template)
|
||
int pyychar;
|
||
struct obstack *obstackp;
|
||
int is_template;
|
||
{
|
||
register int c = 0;
|
||
int blev = 1;
|
||
int starting_lineno = lineno;
|
||
char *starting_filename = input_filename;
|
||
int len;
|
||
int look_for_semicolon = 0;
|
||
int look_for_lbrac = 0;
|
||
|
||
if (pyychar == '{')
|
||
obstack_1grow (obstackp, '{');
|
||
else if (pyychar == '=')
|
||
look_for_semicolon = 1;
|
||
else if (pyychar == ':')
|
||
{
|
||
obstack_1grow (obstackp, pyychar);
|
||
look_for_lbrac = 1;
|
||
blev = 0;
|
||
}
|
||
else if (pyychar == RETURN && !is_template)
|
||
{
|
||
obstack_grow (obstackp, "return", 6);
|
||
look_for_lbrac = 1;
|
||
blev = 0;
|
||
}
|
||
else if (pyychar == TRY && !is_template)
|
||
{
|
||
obstack_grow (obstackp, "try", 3);
|
||
look_for_lbrac = 1;
|
||
blev = 0;
|
||
}
|
||
else
|
||
{
|
||
yyerror (is_template
|
||
? "parse error in template specification"
|
||
: "parse error in method specification");
|
||
obstack_1grow (obstackp, '{');
|
||
}
|
||
|
||
if (nextchar != EOF)
|
||
{
|
||
c = nextchar;
|
||
nextchar = EOF;
|
||
}
|
||
else
|
||
c = getch ();
|
||
|
||
while (c != EOF)
|
||
{
|
||
int this_lineno = lineno;
|
||
|
||
c = skip_white_space (c);
|
||
|
||
/* Don't lose our cool if there are lots of comments. */
|
||
if (lineno == this_lineno + 1)
|
||
obstack_1grow (obstackp, '\n');
|
||
else if (lineno == this_lineno)
|
||
;
|
||
else if (lineno - this_lineno < 10)
|
||
{
|
||
int i;
|
||
for (i = lineno - this_lineno; i > 0; i--)
|
||
obstack_1grow (obstackp, '\n');
|
||
}
|
||
else
|
||
{
|
||
char buf[16];
|
||
sprintf (buf, "\n# %d \"", lineno);
|
||
len = strlen (buf);
|
||
obstack_grow (obstackp, buf, len);
|
||
|
||
len = strlen (input_filename);
|
||
obstack_grow (obstackp, input_filename, len);
|
||
obstack_1grow (obstackp, '\"');
|
||
obstack_1grow (obstackp, '\n');
|
||
}
|
||
|
||
while (c > ' ') /* ASCII dependent... */
|
||
{
|
||
obstack_1grow (obstackp, c);
|
||
if (c == '{')
|
||
{
|
||
look_for_lbrac = 0;
|
||
blev++;
|
||
}
|
||
else if (c == '}')
|
||
{
|
||
blev--;
|
||
if (blev == 0 && !look_for_semicolon)
|
||
{
|
||
if (pyychar == TRY)
|
||
{
|
||
if (peekyylex () == CATCH)
|
||
{
|
||
yylex ();
|
||
obstack_grow (obstackp, " catch ", 7);
|
||
look_for_lbrac = 1;
|
||
}
|
||
else
|
||
{
|
||
yychar = '{';
|
||
goto done;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
goto done;
|
||
}
|
||
}
|
||
}
|
||
else if (c == '\\')
|
||
{
|
||
/* Don't act on the next character...e.g, doing an escaped
|
||
double-quote. */
|
||
c = getch ();
|
||
if (c == EOF)
|
||
{
|
||
error_with_file_and_line (starting_filename,
|
||
starting_lineno,
|
||
"end of file read inside definition");
|
||
goto done;
|
||
}
|
||
obstack_1grow (obstackp, c);
|
||
}
|
||
else if (c == '\"')
|
||
consume_string (obstackp, c);
|
||
else if (c == '\'')
|
||
consume_string (obstackp, c);
|
||
else if (c == ';')
|
||
{
|
||
if (look_for_lbrac)
|
||
{
|
||
error (is_template
|
||
? "template body missing"
|
||
: "function body for constructor missing");
|
||
obstack_1grow (obstackp, '{');
|
||
obstack_1grow (obstackp, '}');
|
||
len += 2;
|
||
goto done;
|
||
}
|
||
else if (look_for_semicolon && blev == 0)
|
||
goto done;
|
||
}
|
||
c = getch ();
|
||
}
|
||
|
||
if (c == EOF)
|
||
{
|
||
error_with_file_and_line (starting_filename,
|
||
starting_lineno,
|
||
"end of file read inside definition");
|
||
goto done;
|
||
}
|
||
else if (c != '\n')
|
||
{
|
||
obstack_1grow (obstackp, c);
|
||
c = getch ();
|
||
}
|
||
}
|
||
done:
|
||
obstack_1grow (obstackp, '\0');
|
||
}
|
||
|
||
/* Build a default function named NAME for type TYPE.
|
||
KIND says what to build.
|
||
|
||
When KIND == 0, build default destructor.
|
||
When KIND == 1, build virtual destructor.
|
||
When KIND == 2, build default constructor.
|
||
When KIND == 3, build default X(const X&) constructor.
|
||
When KIND == 4, build default X(X&) constructor.
|
||
When KIND == 5, build default operator = (const X&).
|
||
When KIND == 6, build default operator = (X&). */
|
||
|
||
tree
|
||
cons_up_default_function (type, full_name, kind)
|
||
tree type, full_name;
|
||
int kind;
|
||
{
|
||
extern tree void_list_node;
|
||
char *func_buf = NULL;
|
||
int func_len = 0;
|
||
tree declspecs = NULL_TREE;
|
||
tree fn, args;
|
||
tree argtype;
|
||
int retref = 0;
|
||
int complex = 0;
|
||
tree name = constructor_name (full_name);
|
||
|
||
switch (kind)
|
||
{
|
||
/* Destructors. */
|
||
case 1:
|
||
declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
|
||
/* Fall through... */
|
||
case 0:
|
||
name = build_parse_node (BIT_NOT_EXPR, name);
|
||
args = void_list_node;
|
||
break;
|
||
|
||
case 2:
|
||
/* Default constructor. */
|
||
args = void_list_node;
|
||
complex = TYPE_NEEDS_CONSTRUCTING (type);
|
||
break;
|
||
|
||
case 3:
|
||
type = build_type_variant (type, 1, 0);
|
||
/* Fall through... */
|
||
case 4:
|
||
/* According to ARM $12.8, the default copy ctor will be declared, but
|
||
not defined, unless it's needed. */
|
||
argtype = build_reference_type (type);
|
||
args = tree_cons (NULL_TREE,
|
||
build_tree_list (hash_tree_chain (argtype, NULL_TREE),
|
||
get_identifier ("_ctor_arg")),
|
||
void_list_node);
|
||
complex = TYPE_HAS_COMPLEX_INIT_REF (type);
|
||
break;
|
||
|
||
case 5:
|
||
type = build_type_variant (type, 1, 0);
|
||
/* Fall through... */
|
||
case 6:
|
||
retref = 1;
|
||
declspecs = build_decl_list (NULL_TREE, full_name);
|
||
|
||
name = ansi_opname [(int) MODIFY_EXPR];
|
||
|
||
argtype = build_reference_type (type);
|
||
args = tree_cons (NULL_TREE,
|
||
build_tree_list (hash_tree_chain (argtype, NULL_TREE),
|
||
get_identifier ("_ctor_arg")),
|
||
void_list_node);
|
||
complex = TYPE_HAS_COMPLEX_ASSIGN_REF (type);
|
||
break;
|
||
|
||
default:
|
||
my_friendly_abort (59);
|
||
}
|
||
|
||
declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
|
||
declspecs);
|
||
|
||
TREE_PARMLIST (args) = 1;
|
||
|
||
{
|
||
tree declarator = build_parse_node (CALL_EXPR, name, args, NULL_TREE);
|
||
if (retref)
|
||
declarator = build_parse_node (ADDR_EXPR, declarator);
|
||
|
||
fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE,
|
||
NULL_TREE, NULL_TREE);
|
||
}
|
||
|
||
if (fn == void_type_node)
|
||
return fn;
|
||
|
||
if (processing_template_defn)
|
||
{
|
||
SET_DECL_IMPLICIT_INSTANTIATION (fn);
|
||
repo_template_used (fn);
|
||
}
|
||
|
||
if (CLASSTYPE_INTERFACE_KNOWN (type))
|
||
{
|
||
DECL_INTERFACE_KNOWN (fn) = 1;
|
||
DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
|
||
&& flag_implement_inlines);
|
||
}
|
||
else
|
||
DECL_NOT_REALLY_EXTERN (fn) = 1;
|
||
|
||
#if 0
|
||
/* When on-the-fly synthesis works properly, remove the second and third
|
||
conditions here. */
|
||
if (flag_keep_inline_functions
|
||
#if 0
|
||
|| ! flag_no_inline
|
||
|| complex
|
||
#endif
|
||
|| ! DECL_EXTERNAL (fn))
|
||
{
|
||
struct pending_inline *t;
|
||
t = (struct pending_inline *)
|
||
obstack_alloc (&synth_obstack, sizeof (struct pending_inline));
|
||
t->lineno = -kind;
|
||
t->can_free = 0;
|
||
t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
|
||
store_pending_inline (fn, t);
|
||
}
|
||
else
|
||
#endif
|
||
mark_inline_for_output (fn);
|
||
|
||
#ifdef DEBUG_DEFAULT_FUNCTIONS
|
||
{ char *fn_type = NULL;
|
||
tree t = name;
|
||
switch (kind)
|
||
{
|
||
case 0: fn_type = "default destructor"; break;
|
||
case 1: fn_type = "virtual destructor"; break;
|
||
case 2: fn_type = "default constructor"; break;
|
||
case 3: fn_type = "default X(const X&)"; break;
|
||
case 4: fn_type = "default X(X&)"; break;
|
||
}
|
||
if (fn_type)
|
||
{
|
||
if (TREE_CODE (name) == BIT_NOT_EXPR)
|
||
t = TREE_OPERAND (name, 0);
|
||
fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
|
||
IDENTIFIER_POINTER (t), func_buf);
|
||
}
|
||
}
|
||
#endif /* DEBUG_DEFAULT_FUNCTIONS */
|
||
|
||
/* Show that this function was generated by the compiler. */
|
||
SET_DECL_ARTIFICIAL (fn);
|
||
|
||
return fn;
|
||
}
|
||
|
||
/* Heuristic to tell whether the user is missing a semicolon
|
||
after a struct or enum declaration. Emit an error message
|
||
if we know the user has blown it. */
|
||
void
|
||
check_for_missing_semicolon (type)
|
||
tree type;
|
||
{
|
||
if (yychar < 0)
|
||
yychar = yylex ();
|
||
|
||
if ((yychar > 255
|
||
&& yychar != SCSPEC
|
||
&& yychar != IDENTIFIER
|
||
&& yychar != TYPENAME)
|
||
|| end_of_file)
|
||
{
|
||
if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
|
||
error ("semicolon missing after %s declaration",
|
||
TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
|
||
else
|
||
cp_error ("semicolon missing after declaration of `%T'", type);
|
||
shadow_tag (build_tree_list (0, type));
|
||
}
|
||
/* Could probably also hack cases where class { ... } f (); appears. */
|
||
clear_anon_tags ();
|
||
}
|
||
|
||
void
|
||
note_got_semicolon (type)
|
||
tree type;
|
||
{
|
||
if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
|
||
my_friendly_abort (60);
|
||
if (IS_AGGR_TYPE (type))
|
||
CLASSTYPE_GOT_SEMICOLON (type) = 1;
|
||
}
|
||
|
||
void
|
||
note_list_got_semicolon (declspecs)
|
||
tree declspecs;
|
||
{
|
||
tree link;
|
||
|
||
for (link = declspecs; link; link = TREE_CHAIN (link))
|
||
{
|
||
tree type = TREE_VALUE (link);
|
||
if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
|
||
note_got_semicolon (type);
|
||
}
|
||
clear_anon_tags ();
|
||
}
|
||
|
||
/* If C is not whitespace, return C.
|
||
Otherwise skip whitespace and return first nonwhite char read. */
|
||
|
||
static int
|
||
skip_white_space (c)
|
||
register int c;
|
||
{
|
||
for (;;)
|
||
{
|
||
switch (c)
|
||
{
|
||
case '\n':
|
||
c = check_newline ();
|
||
break;
|
||
|
||
case ' ':
|
||
case '\t':
|
||
case '\f':
|
||
case '\r':
|
||
case '\v':
|
||
case '\b':
|
||
do
|
||
c = getch ();
|
||
while (c == ' ' || c == '\t');
|
||
break;
|
||
|
||
case '\\':
|
||
c = getch ();
|
||
if (c == '\n')
|
||
lineno++;
|
||
else
|
||
error ("stray '\\' in program");
|
||
c = getch ();
|
||
break;
|
||
|
||
default:
|
||
return (c);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* Make the token buffer longer, preserving the data in it.
|
||
P should point to just beyond the last valid character in the old buffer.
|
||
The value we return is a pointer to the new buffer
|
||
at a place corresponding to P. */
|
||
|
||
static char *
|
||
extend_token_buffer (p)
|
||
char *p;
|
||
{
|
||
int offset = p - token_buffer;
|
||
|
||
maxtoken = maxtoken * 2 + 10;
|
||
token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
|
||
|
||
return token_buffer + offset;
|
||
}
|
||
|
||
static int
|
||
get_last_nonwhite_on_line ()
|
||
{
|
||
register int c;
|
||
|
||
/* Is this the last nonwhite stuff on the line? */
|
||
if (nextchar >= 0)
|
||
c = nextchar, nextchar = -1;
|
||
else
|
||
c = getch ();
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
return c;
|
||
}
|
||
|
||
/* At the beginning of a line, increment the line number
|
||
and process any #-directive on this line.
|
||
If the line is a #-directive, read the entire line and return a newline.
|
||
Otherwise, return the line's first non-whitespace character. */
|
||
|
||
int linemode;
|
||
|
||
int
|
||
check_newline ()
|
||
{
|
||
register int c;
|
||
register int token;
|
||
|
||
/* Read first nonwhite char on the line. Do this before incrementing the
|
||
line number, in case we're at the end of saved text. */
|
||
|
||
do
|
||
c = getch ();
|
||
while (c == ' ' || c == '\t');
|
||
|
||
lineno++;
|
||
|
||
if (c != '#')
|
||
{
|
||
/* If not #, return it so caller will use it. */
|
||
return c;
|
||
}
|
||
|
||
/* Don't read beyond this line. */
|
||
linemode = 1;
|
||
|
||
/* Read first nonwhite char after the `#'. */
|
||
|
||
do
|
||
c = getch ();
|
||
while (c == ' ' || c == '\t');
|
||
|
||
/* If a letter follows, then if the word here is `line', skip
|
||
it and ignore it; otherwise, ignore the line, with an error
|
||
if the word isn't `pragma'. */
|
||
|
||
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
|
||
{
|
||
if (c == 'p')
|
||
{
|
||
if (getch () == 'r'
|
||
&& getch () == 'a'
|
||
&& getch () == 'g'
|
||
&& getch () == 'm'
|
||
&& getch () == 'a')
|
||
{
|
||
/* Read first nonwhite char after the `#pragma'. */
|
||
|
||
do
|
||
c = getch ();
|
||
while (c == ' ' || c == '\t');
|
||
|
||
if (c == 'v'
|
||
&& getch () == 't'
|
||
&& getch () == 'a'
|
||
&& getch () == 'b'
|
||
&& getch () == 'l'
|
||
&& getch () == 'e'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
extern tree pending_vtables;
|
||
|
||
/* More follows: it must be a string constant (class name). */
|
||
token = real_yylex ();
|
||
if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #pragma vtable");
|
||
goto skipline;
|
||
}
|
||
if (write_virtuals != 2)
|
||
{
|
||
warning ("use `+e2' option to enable #pragma vtable");
|
||
goto skipline;
|
||
}
|
||
pending_vtables = perm_tree_cons (NULL_TREE, get_identifier (TREE_STRING_POINTER (yylval.ttype)), pending_vtables);
|
||
if (nextchar < 0)
|
||
nextchar = getch ();
|
||
c = nextchar;
|
||
if (c != EOF)
|
||
warning ("trailing characters ignored");
|
||
}
|
||
else if (c == 'u'
|
||
&& getch () == 'n'
|
||
&& getch () == 'i'
|
||
&& getch () == 't'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
/* More follows: it must be a string constant (unit name). */
|
||
token = real_yylex ();
|
||
if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #pragma unit");
|
||
goto skipline;
|
||
}
|
||
current_unit_name = get_identifier (TREE_STRING_POINTER (yylval.ttype));
|
||
current_unit_language = current_lang_name;
|
||
if (nextchar < 0)
|
||
nextchar = getch ();
|
||
c = nextchar;
|
||
if (c != EOF)
|
||
warning ("trailing characters ignored");
|
||
}
|
||
else if (c == 'i')
|
||
{
|
||
tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
|
||
c = getch ();
|
||
|
||
if (c == 'n'
|
||
&& getch () == 't'
|
||
&& getch () == 'e'
|
||
&& getch () == 'r'
|
||
&& getch () == 'f'
|
||
&& getch () == 'a'
|
||
&& getch () == 'c'
|
||
&& getch () == 'e'
|
||
&& ((c = getch ()) == ' ' || c == '\t' || c == EOF))
|
||
{
|
||
int warned_already = 0;
|
||
char *main_filename = input_filename;
|
||
|
||
main_filename = FILE_NAME_NONDIRECTORY (main_filename);
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
if (c != EOF)
|
||
{
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
if (token != STRING
|
||
|| TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid `#pragma interface'");
|
||
goto skipline;
|
||
}
|
||
main_filename = TREE_STRING_POINTER (yylval.ttype);
|
||
c = getch();
|
||
put_back (c);
|
||
}
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
|
||
while (c != EOF)
|
||
{
|
||
if (!warned_already && extra_warnings
|
||
&& c != ' ' && c != '\t')
|
||
{
|
||
warning ("garbage after `#pragma interface' ignored");
|
||
warned_already = 1;
|
||
}
|
||
c = getch ();
|
||
}
|
||
|
||
write_virtuals = 3;
|
||
|
||
if (impl_file_chain == 0)
|
||
{
|
||
/* If this is zero at this point, then we are
|
||
auto-implementing. */
|
||
if (main_input_filename == 0)
|
||
main_input_filename = input_filename;
|
||
|
||
#ifdef AUTO_IMPLEMENT
|
||
filename = FILE_NAME_NONDIRECTORY (main_input_filename);
|
||
fi = get_time_identifier (filename);
|
||
fi = IDENTIFIER_CLASS_VALUE (fi);
|
||
TREE_INT_CST_LOW (fi) = 0;
|
||
TREE_INT_CST_HIGH (fi) = 1;
|
||
/* Get default. */
|
||
impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
|
||
impl_file_chain->filename = filename;
|
||
impl_file_chain->next = 0;
|
||
#endif
|
||
}
|
||
|
||
interface_only = interface_strcmp (main_filename);
|
||
interface_unknown = 0;
|
||
TREE_INT_CST_LOW (fileinfo) = interface_only;
|
||
TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
|
||
}
|
||
else if (c == 'm'
|
||
&& getch () == 'p'
|
||
&& getch () == 'l'
|
||
&& getch () == 'e'
|
||
&& getch () == 'm'
|
||
&& getch () == 'e'
|
||
&& getch () == 'n'
|
||
&& getch () == 't'
|
||
&& getch () == 'a'
|
||
&& getch () == 't'
|
||
&& getch () == 'i'
|
||
&& getch () == 'o'
|
||
&& getch () == 'n'
|
||
&& ((c = getch ()) == ' ' || c == '\t' || c == EOF))
|
||
{
|
||
int warned_already = 0;
|
||
char *main_filename = main_input_filename ? main_input_filename : input_filename;
|
||
|
||
main_filename = FILE_NAME_NONDIRECTORY (main_filename);
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
if (c != EOF)
|
||
{
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
if (token != STRING
|
||
|| TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid `#pragma implementation'");
|
||
goto skipline;
|
||
}
|
||
main_filename = TREE_STRING_POINTER (yylval.ttype);
|
||
c = getch();
|
||
put_back (c);
|
||
}
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
|
||
while (c != EOF)
|
||
{
|
||
if (!warned_already && extra_warnings
|
||
&& c != ' ' && c != '\t')
|
||
{
|
||
warning ("garbage after `#pragma implementation' ignored");
|
||
warned_already = 1;
|
||
}
|
||
c = getch ();
|
||
}
|
||
|
||
if (write_virtuals == 3)
|
||
{
|
||
struct impl_files *ifiles = impl_file_chain;
|
||
while (ifiles)
|
||
{
|
||
if (! strcmp (ifiles->filename, main_filename))
|
||
break;
|
||
ifiles = ifiles->next;
|
||
}
|
||
if (ifiles == 0)
|
||
{
|
||
ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
|
||
ifiles->filename = main_filename;
|
||
ifiles->next = impl_file_chain;
|
||
impl_file_chain = ifiles;
|
||
}
|
||
}
|
||
else if ((main_input_filename != 0
|
||
&& ! strcmp (main_input_filename, input_filename))
|
||
|| ! strcmp (input_filename, main_filename))
|
||
{
|
||
write_virtuals = 3;
|
||
if (impl_file_chain == 0)
|
||
{
|
||
impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
|
||
impl_file_chain->filename = main_filename;
|
||
impl_file_chain->next = 0;
|
||
}
|
||
}
|
||
else
|
||
error ("`#pragma implementation' can only appear at top-level");
|
||
interface_only = 0;
|
||
#if 1
|
||
/* We make this non-zero so that we infer decl linkage
|
||
in the impl file only for variables first declared
|
||
in the interface file. */
|
||
interface_unknown = 1;
|
||
#else
|
||
/* We make this zero so that templates in the impl
|
||
file will be emitted properly. */
|
||
interface_unknown = 0;
|
||
#endif
|
||
TREE_INT_CST_LOW (fileinfo) = interface_only;
|
||
TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
|
||
}
|
||
}
|
||
#ifdef HANDLE_SYSV_PRAGMA
|
||
else
|
||
{
|
||
put_back (c);
|
||
handle_sysv_pragma ();
|
||
}
|
||
#else
|
||
#ifdef HANDLE_PRAGMA
|
||
/* FIXME: This will break if we're doing any of the C++ input
|
||
tricks. */
|
||
else
|
||
{
|
||
ungetc (c, finput);
|
||
HANDLE_PRAGMA (finput);
|
||
}
|
||
#endif
|
||
#endif
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'd')
|
||
{
|
||
if (getch () == 'e'
|
||
&& getch () == 'f'
|
||
&& getch () == 'i'
|
||
&& getch () == 'n'
|
||
&& getch () == 'e'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
#ifdef DWARF_DEBUGGING_INFO
|
||
if ((debug_info_level == DINFO_LEVEL_VERBOSE)
|
||
&& (write_symbols == DWARF_DEBUG))
|
||
dwarfout_define (lineno, get_directive_line (finput));
|
||
#endif /* DWARF_DEBUGGING_INFO */
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'u')
|
||
{
|
||
if (getch () == 'n'
|
||
&& getch () == 'd'
|
||
&& getch () == 'e'
|
||
&& getch () == 'f'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
#ifdef DWARF_DEBUGGING_INFO
|
||
if ((debug_info_level == DINFO_LEVEL_VERBOSE)
|
||
&& (write_symbols == DWARF_DEBUG))
|
||
dwarfout_undef (lineno, get_directive_line (finput));
|
||
#endif /* DWARF_DEBUGGING_INFO */
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'l')
|
||
{
|
||
if (getch () == 'i'
|
||
&& getch () == 'n'
|
||
&& getch () == 'e'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
goto linenum;
|
||
}
|
||
else if (c == 'i')
|
||
{
|
||
if (getch () == 'd'
|
||
&& getch () == 'e'
|
||
&& getch () == 'n'
|
||
&& getch () == 't'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
#ifdef ASM_OUTPUT_IDENT
|
||
extern FILE *asm_out_file;
|
||
#endif
|
||
/* #ident. The pedantic warning is now in cccp.c. */
|
||
|
||
/* Here we have just seen `#ident '.
|
||
A string constant should follow. */
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
|
||
/* If no argument, ignore the line. */
|
||
if (c == EOF)
|
||
goto skipline;
|
||
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
if (token != STRING
|
||
|| TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #ident");
|
||
goto skipline;
|
||
}
|
||
|
||
if (! flag_no_ident)
|
||
{
|
||
#ifdef ASM_OUTPUT_IDENT
|
||
ASM_OUTPUT_IDENT (asm_out_file,
|
||
TREE_STRING_POINTER (yylval.ttype));
|
||
#endif
|
||
}
|
||
|
||
/* Skip the rest of this line. */
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'n')
|
||
{
|
||
if (getch () == 'e'
|
||
&& getch () == 'w'
|
||
&& getch () == 'w'
|
||
&& getch () == 'o'
|
||
&& getch () == 'r'
|
||
&& getch () == 'l'
|
||
&& getch () == 'd'
|
||
&& ((c = getch ()) == ' ' || c == '\t'))
|
||
{
|
||
/* Used to test incremental compilation. */
|
||
sorry ("#pragma newworld");
|
||
goto skipline;
|
||
}
|
||
}
|
||
error ("undefined or invalid # directive");
|
||
goto skipline;
|
||
}
|
||
|
||
linenum:
|
||
/* Here we have either `#line' or `# <nonletter>'.
|
||
In either case, it should be a line number; a digit should follow. */
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = getch ();
|
||
|
||
/* If the # is the only nonwhite char on the line,
|
||
just ignore it. Check the new newline. */
|
||
if (c == EOF)
|
||
goto skipline;
|
||
|
||
/* Something follows the #; read a token. */
|
||
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
|
||
if (token == CONSTANT
|
||
&& TREE_CODE (yylval.ttype) == INTEGER_CST)
|
||
{
|
||
int old_lineno = lineno;
|
||
enum { act_none, act_push, act_pop } action = act_none;
|
||
int entering_system_header = 0;
|
||
int entering_c_header = 0;
|
||
|
||
/* subtract one, because it is the following line that
|
||
gets the specified number */
|
||
|
||
int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
|
||
c = get_last_nonwhite_on_line ();
|
||
if (c == EOF)
|
||
{
|
||
/* No more: store the line number and check following line. */
|
||
lineno = l;
|
||
goto skipline;
|
||
}
|
||
put_back (c);
|
||
|
||
/* More follows: it must be a string constant (filename). */
|
||
|
||
/* Read the string constant, but don't treat \ as special. */
|
||
ignore_escape_flag = 1;
|
||
token = real_yylex ();
|
||
ignore_escape_flag = 0;
|
||
|
||
if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #line");
|
||
goto skipline;
|
||
}
|
||
|
||
/* Changing files again. This means currently collected time
|
||
is charged against header time, and body time starts back
|
||
at 0. */
|
||
if (flag_detailed_statistics)
|
||
{
|
||
int this_time = my_get_run_time ();
|
||
tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
|
||
header_time += this_time - body_time;
|
||
TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
|
||
+= this_time - body_time;
|
||
this_filename_time = time_identifier;
|
||
body_time = this_time;
|
||
}
|
||
|
||
if (flag_cadillac)
|
||
cadillac_note_source ();
|
||
|
||
input_filename
|
||
= (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
|
||
strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
|
||
lineno = l;
|
||
GNU_xref_file (input_filename);
|
||
|
||
if (main_input_filename == 0)
|
||
{
|
||
struct impl_files *ifiles = impl_file_chain;
|
||
|
||
if (ifiles)
|
||
{
|
||
while (ifiles->next)
|
||
ifiles = ifiles->next;
|
||
ifiles->filename = FILE_NAME_NONDIRECTORY (input_filename);
|
||
}
|
||
|
||
main_input_filename = input_filename;
|
||
if (write_virtuals == 3)
|
||
walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
|
||
}
|
||
|
||
extract_interface_info ();
|
||
|
||
c = get_last_nonwhite_on_line ();
|
||
if (c == EOF)
|
||
{
|
||
/* Update the name in the top element of input_file_stack. */
|
||
if (input_file_stack)
|
||
input_file_stack->name = input_filename;
|
||
}
|
||
else
|
||
{
|
||
put_back (c);
|
||
|
||
token = real_yylex ();
|
||
|
||
/* `1' after file name means entering new file.
|
||
`2' after file name means just left a file. */
|
||
|
||
if (token == CONSTANT
|
||
&& TREE_CODE (yylval.ttype) == INTEGER_CST)
|
||
{
|
||
if (TREE_INT_CST_LOW (yylval.ttype) == 1)
|
||
action = act_push;
|
||
else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
|
||
action = act_pop;
|
||
|
||
if (action)
|
||
{
|
||
c = get_last_nonwhite_on_line ();
|
||
if (c != EOF)
|
||
{
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
}
|
||
}
|
||
}
|
||
|
||
/* `3' after file name means this is a system header file. */
|
||
|
||
if (token == CONSTANT
|
||
&& TREE_CODE (yylval.ttype) == INTEGER_CST
|
||
&& TREE_INT_CST_LOW (yylval.ttype) == 3)
|
||
{
|
||
entering_system_header = 1;
|
||
|
||
c = get_last_nonwhite_on_line ();
|
||
if (c != EOF)
|
||
{
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
}
|
||
}
|
||
|
||
/* `4' after file name means this is a C header file. */
|
||
|
||
if (token == CONSTANT
|
||
&& TREE_CODE (yylval.ttype) == INTEGER_CST
|
||
&& TREE_INT_CST_LOW (yylval.ttype) == 4)
|
||
{
|
||
entering_c_header = 1;
|
||
|
||
c = get_last_nonwhite_on_line ();
|
||
if (c != EOF)
|
||
{
|
||
put_back (c);
|
||
token = real_yylex ();
|
||
}
|
||
}
|
||
|
||
/* Do the actions implied by the preceding numbers. */
|
||
|
||
if (action == act_push)
|
||
{
|
||
/* Pushing to a new file. */
|
||
struct file_stack *p;
|
||
|
||
p = (struct file_stack *) xmalloc (sizeof (struct file_stack));
|
||
input_file_stack->line = old_lineno;
|
||
p->next = input_file_stack;
|
||
p->name = input_filename;
|
||
input_file_stack = p;
|
||
input_file_stack_tick++;
|
||
#ifdef DWARF_DEBUGGING_INFO
|
||
if (debug_info_level == DINFO_LEVEL_VERBOSE
|
||
&& write_symbols == DWARF_DEBUG)
|
||
dwarfout_start_new_source_file (input_filename);
|
||
#endif /* DWARF_DEBUGGING_INFO */
|
||
if (flag_cadillac)
|
||
cadillac_push_source ();
|
||
in_system_header = entering_system_header;
|
||
if (c_header_level)
|
||
++c_header_level;
|
||
else if (entering_c_header)
|
||
{
|
||
c_header_level = 1;
|
||
++pending_lang_change;
|
||
}
|
||
}
|
||
else if (action == act_pop)
|
||
{
|
||
/* Popping out of a file. */
|
||
if (input_file_stack->next)
|
||
{
|
||
struct file_stack *p;
|
||
|
||
if (c_header_level && --c_header_level == 0)
|
||
{
|
||
if (entering_c_header)
|
||
warning ("badly nested C headers from preprocessor");
|
||
--pending_lang_change;
|
||
}
|
||
if (flag_cadillac)
|
||
cadillac_pop_source ();
|
||
in_system_header = entering_system_header;
|
||
|
||
p = input_file_stack;
|
||
input_file_stack = p->next;
|
||
free (p);
|
||
input_file_stack_tick++;
|
||
#ifdef DWARF_DEBUGGING_INFO
|
||
if (debug_info_level == DINFO_LEVEL_VERBOSE
|
||
&& write_symbols == DWARF_DEBUG)
|
||
dwarfout_resume_previous_source_file (input_file_stack->line);
|
||
#endif /* DWARF_DEBUGGING_INFO */
|
||
}
|
||
else
|
||
error ("#-lines for entering and leaving files don't match");
|
||
}
|
||
else
|
||
{
|
||
in_system_header = entering_system_header;
|
||
if (flag_cadillac)
|
||
cadillac_switch_source (-1);
|
||
}
|
||
}
|
||
|
||
/* If NEXTCHAR is not end of line, we don't care what it is. */
|
||
if (nextchar == EOF)
|
||
c = EOF;
|
||
}
|
||
else
|
||
error ("invalid #-line");
|
||
|
||
/* skip the rest of this line. */
|
||
skipline:
|
||
linemode = 0;
|
||
end_of_file = 0;
|
||
while ((c = getch ()) != EOF && c != '\n');
|
||
return c;
|
||
}
|
||
|
||
void
|
||
do_pending_lang_change ()
|
||
{
|
||
for (; pending_lang_change > 0; --pending_lang_change)
|
||
push_lang_context (lang_name_c);
|
||
for (; pending_lang_change < 0; ++pending_lang_change)
|
||
pop_lang_context ();
|
||
}
|
||
|
||
#if 0
|
||
#define isalnum(char) (char >= 'a' ? char <= 'z' : char >= '0' ? char <= '9' || (char >= 'A' && char <= 'Z') : 0)
|
||
#define isdigit(char) (char >= '0' && char <= '9')
|
||
#else
|
||
#include <ctype.h>
|
||
#endif
|
||
|
||
#define ENDFILE -1 /* token that represents end-of-file */
|
||
|
||
/* Read an escape sequence, returning its equivalent as a character,
|
||
or store 1 in *ignore_ptr if it is backslash-newline. */
|
||
|
||
static int
|
||
readescape (ignore_ptr)
|
||
int *ignore_ptr;
|
||
{
|
||
register int c = getch ();
|
||
register int code;
|
||
register unsigned count;
|
||
unsigned firstdig;
|
||
int nonnull;
|
||
|
||
switch (c)
|
||
{
|
||
case 'x':
|
||
if (warn_traditional)
|
||
warning ("the meaning of `\\x' varies with -traditional");
|
||
|
||
if (flag_traditional)
|
||
return c;
|
||
|
||
code = 0;
|
||
count = 0;
|
||
nonnull = 0;
|
||
while (1)
|
||
{
|
||
c = getch ();
|
||
if (! isxdigit (c))
|
||
{
|
||
put_back (c);
|
||
break;
|
||
}
|
||
code *= 16;
|
||
if (c >= 'a' && c <= 'f')
|
||
code += c - 'a' + 10;
|
||
if (c >= 'A' && c <= 'F')
|
||
code += c - 'A' + 10;
|
||
if (c >= '0' && c <= '9')
|
||
code += c - '0';
|
||
if (code != 0 || count != 0)
|
||
{
|
||
if (count == 0)
|
||
firstdig = code;
|
||
count++;
|
||
}
|
||
nonnull = 1;
|
||
}
|
||
if (! nonnull)
|
||
error ("\\x used with no following hex digits");
|
||
else if (count == 0)
|
||
/* Digits are all 0's. Ok. */
|
||
;
|
||
else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
|
||
|| (count > 1
|
||
&& ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
|
||
<= firstdig)))
|
||
pedwarn ("hex escape out of range");
|
||
return code;
|
||
|
||
case '0': case '1': case '2': case '3': case '4':
|
||
case '5': case '6': case '7':
|
||
code = 0;
|
||
count = 0;
|
||
while ((c <= '7') && (c >= '0') && (count++ < 3))
|
||
{
|
||
code = (code * 8) + (c - '0');
|
||
c = getch ();
|
||
}
|
||
put_back (c);
|
||
return code;
|
||
|
||
case '\\': case '\'': case '"':
|
||
return c;
|
||
|
||
case '\n':
|
||
lineno++;
|
||
*ignore_ptr = 1;
|
||
return 0;
|
||
|
||
case 'n':
|
||
return TARGET_NEWLINE;
|
||
|
||
case 't':
|
||
return TARGET_TAB;
|
||
|
||
case 'r':
|
||
return TARGET_CR;
|
||
|
||
case 'f':
|
||
return TARGET_FF;
|
||
|
||
case 'b':
|
||
return TARGET_BS;
|
||
|
||
case 'a':
|
||
if (warn_traditional)
|
||
warning ("the meaning of `\\a' varies with -traditional");
|
||
|
||
if (flag_traditional)
|
||
return c;
|
||
return TARGET_BELL;
|
||
|
||
case 'v':
|
||
return TARGET_VT;
|
||
|
||
case 'e':
|
||
case 'E':
|
||
if (pedantic)
|
||
pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
|
||
return 033;
|
||
|
||
case '?':
|
||
return c;
|
||
|
||
/* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
|
||
case '(':
|
||
case '{':
|
||
case '[':
|
||
/* `\%' is used to prevent SCCS from getting confused. */
|
||
case '%':
|
||
if (pedantic)
|
||
pedwarn ("unknown escape sequence `\\%c'", c);
|
||
return c;
|
||
}
|
||
if (c >= 040 && c < 0177)
|
||
pedwarn ("unknown escape sequence `\\%c'", c);
|
||
else
|
||
pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
|
||
return c;
|
||
}
|
||
|
||
/* Value is 1 (or 2) if we should try to make the next identifier look like
|
||
a typename (when it may be a local variable or a class variable).
|
||
Value is 0 if we treat this name in a default fashion. */
|
||
int looking_for_typename = 0;
|
||
|
||
#if 0
|
||
/* NO LONGER USED: Value is -1 if we must not see a type name. */
|
||
void
|
||
dont_see_typename ()
|
||
{
|
||
looking_for_typename = -1;
|
||
if (yychar == TYPENAME || yychar == PTYPENAME)
|
||
{
|
||
yychar = IDENTIFIER;
|
||
lastiddecl = 0;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifdef __GNUC__
|
||
extern __inline int identifier_type ();
|
||
__inline
|
||
#endif
|
||
int
|
||
identifier_type (decl)
|
||
tree decl;
|
||
{
|
||
if (TREE_CODE (decl) == TEMPLATE_DECL
|
||
&& DECL_TEMPLATE_IS_CLASS (decl))
|
||
return PTYPENAME;
|
||
if (TREE_CODE (decl) == NAMESPACE_DECL)
|
||
return NSNAME;
|
||
if (TREE_CODE (decl) != TYPE_DECL)
|
||
return IDENTIFIER;
|
||
return TYPENAME;
|
||
}
|
||
|
||
void
|
||
see_typename ()
|
||
{
|
||
looking_for_typename = 1;
|
||
if (yychar < 0)
|
||
if ((yychar = yylex()) < 0) yychar = 0;
|
||
looking_for_typename = 0;
|
||
if (yychar == IDENTIFIER)
|
||
{
|
||
lastiddecl = lookup_name (yylval.ttype, -2);
|
||
if (lastiddecl == 0)
|
||
{
|
||
if (flag_labels_ok)
|
||
lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
|
||
}
|
||
else
|
||
yychar = identifier_type (lastiddecl);
|
||
}
|
||
}
|
||
|
||
tree
|
||
do_identifier (token)
|
||
register tree token;
|
||
{
|
||
register tree id = lastiddecl;
|
||
|
||
if (yychar == YYEMPTY)
|
||
yychar = yylex ();
|
||
/* Scope class declarations before global
|
||
declarations. */
|
||
if (id == IDENTIFIER_GLOBAL_VALUE (token)
|
||
&& current_class_type != 0
|
||
&& TYPE_SIZE (current_class_type) == 0
|
||
&& TREE_CODE (current_class_type) != UNINSTANTIATED_P_TYPE)
|
||
{
|
||
/* Could be from one of the base classes. */
|
||
tree field = lookup_field (current_class_type, token, 1, 0);
|
||
if (field == 0)
|
||
;
|
||
else if (field == error_mark_node)
|
||
/* We have already generated the error message.
|
||
But we still want to return this value. */
|
||
id = lookup_field (current_class_type, token, 0, 0);
|
||
else if (TREE_CODE (field) == VAR_DECL
|
||
|| TREE_CODE (field) == CONST_DECL)
|
||
id = field;
|
||
else if (TREE_CODE (field) != FIELD_DECL)
|
||
my_friendly_abort (61);
|
||
else
|
||
{
|
||
cp_error ("invalid use of member `%D' from base class `%T'", field,
|
||
DECL_FIELD_CONTEXT (field));
|
||
id = error_mark_node;
|
||
return id;
|
||
}
|
||
}
|
||
|
||
/* Remember that this name has been used in the class definition, as per
|
||
[class.scope0] */
|
||
if (id && current_class_type
|
||
&& TYPE_BEING_DEFINED (current_class_type)
|
||
&& ! IDENTIFIER_CLASS_VALUE (token))
|
||
pushdecl_class_level (id);
|
||
|
||
if (!id || id == error_mark_node)
|
||
{
|
||
if (id == error_mark_node && current_class_type != NULL_TREE)
|
||
{
|
||
id = lookup_nested_field (token, 1);
|
||
/* In lookup_nested_field(), we marked this so we can gracefully
|
||
leave this whole mess. */
|
||
if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
|
||
return id;
|
||
}
|
||
if (yychar == '(' || yychar == LEFT_RIGHT)
|
||
{
|
||
id = implicitly_declare (token);
|
||
}
|
||
else if (current_function_decl == 0)
|
||
{
|
||
cp_error ("`%D' was not declared in this scope", token);
|
||
id = error_mark_node;
|
||
}
|
||
else
|
||
{
|
||
if (IDENTIFIER_GLOBAL_VALUE (token) != error_mark_node
|
||
|| IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
|
||
{
|
||
static int undeclared_variable_notice;
|
||
|
||
cp_error ("`%D' undeclared (first use this function)", token);
|
||
|
||
if (! undeclared_variable_notice)
|
||
{
|
||
error ("(Each undeclared identifier is reported only once");
|
||
error ("for each function it appears in.)");
|
||
undeclared_variable_notice = 1;
|
||
}
|
||
}
|
||
id = error_mark_node;
|
||
/* Prevent repeated error messages. */
|
||
IDENTIFIER_GLOBAL_VALUE (token) = error_mark_node;
|
||
SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
|
||
}
|
||
}
|
||
|
||
if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
|
||
{
|
||
tree shadowed = DECL_SHADOWED_FOR_VAR (id);
|
||
if (shadowed)
|
||
{
|
||
if (!DECL_ERROR_REPORTED (id))
|
||
{
|
||
warning ("name lookup of `%s' changed",
|
||
IDENTIFIER_POINTER (token));
|
||
cp_warning_at (" matches this `%D' under current ANSI rules",
|
||
shadowed);
|
||
cp_warning_at (" matches this `%D' under old rules", id);
|
||
DECL_ERROR_REPORTED (id) = 1;
|
||
}
|
||
id = shadowed;
|
||
}
|
||
else if (!DECL_ERROR_REPORTED (id))
|
||
{
|
||
static char msg[]
|
||
= "name lookup of `%s' changed for new ANSI `for' scoping";
|
||
DECL_ERROR_REPORTED (id) = 1;
|
||
if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
|
||
{
|
||
error (msg, IDENTIFIER_POINTER (token));
|
||
cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
|
||
id = error_mark_node;
|
||
}
|
||
else
|
||
{
|
||
pedwarn (msg, IDENTIFIER_POINTER (token));
|
||
cp_pedwarn_at (" using obsolete binding at `%D'", id);
|
||
}
|
||
}
|
||
}
|
||
/* TREE_USED is set in `hack_identifier'. */
|
||
if (TREE_CODE (id) == CONST_DECL)
|
||
{
|
||
if (IDENTIFIER_CLASS_VALUE (token) == id)
|
||
{
|
||
/* Check access. */
|
||
enum access_type access
|
||
= compute_access (TYPE_BINFO (current_class_type), id);
|
||
if (access == access_private)
|
||
cp_error ("enum `%D' is private", id);
|
||
/* protected is OK, since it's an enum of `this'. */
|
||
}
|
||
id = DECL_INITIAL (id);
|
||
}
|
||
else
|
||
id = hack_identifier (id, token, yychar);
|
||
return id;
|
||
}
|
||
|
||
tree
|
||
identifier_typedecl_value (node)
|
||
tree node;
|
||
{
|
||
tree t, type;
|
||
type = IDENTIFIER_TYPE_VALUE (node);
|
||
if (type == NULL_TREE)
|
||
return NULL_TREE;
|
||
#define do(X) \
|
||
{ \
|
||
t = (X); \
|
||
if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
|
||
return t; \
|
||
}
|
||
do (IDENTIFIER_LOCAL_VALUE (node));
|
||
do (IDENTIFIER_CLASS_VALUE (node));
|
||
do (IDENTIFIER_GLOBAL_VALUE (node));
|
||
#undef do
|
||
/* Will this one ever happen? */
|
||
if (TYPE_NAME (type))
|
||
return TYPE_NAME (type);
|
||
|
||
/* We used to do an internal error of 62 here, but instead we will
|
||
handle the return of a null appropriately in the callers. */
|
||
return NULL_TREE;
|
||
}
|
||
|
||
struct try_type
|
||
{
|
||
tree *node_var;
|
||
char unsigned_flag;
|
||
char long_flag;
|
||
char long_long_flag;
|
||
};
|
||
|
||
struct try_type type_sequence[] =
|
||
{
|
||
{ &integer_type_node, 0, 0, 0},
|
||
{ &unsigned_type_node, 1, 0, 0},
|
||
{ &long_integer_type_node, 0, 1, 0},
|
||
{ &long_unsigned_type_node, 1, 1, 0},
|
||
{ &long_long_integer_type_node, 0, 1, 1},
|
||
{ &long_long_unsigned_type_node, 1, 1, 1}
|
||
};
|
||
|
||
int
|
||
real_yylex ()
|
||
{
|
||
register int c;
|
||
register int value;
|
||
int wide_flag = 0;
|
||
int dollar_seen = 0;
|
||
int i;
|
||
|
||
if (nextchar >= 0)
|
||
c = nextchar, nextchar = -1;
|
||
else
|
||
c = getch ();
|
||
|
||
/* Effectively do c = skip_white_space (c)
|
||
but do it faster in the usual cases. */
|
||
while (1)
|
||
switch (c)
|
||
{
|
||
case ' ':
|
||
case '\t':
|
||
case '\f':
|
||
case '\v':
|
||
case '\b':
|
||
c = getch ();
|
||
break;
|
||
|
||
case '\r':
|
||
/* Call skip_white_space so we can warn if appropriate. */
|
||
|
||
case '\n':
|
||
case '/':
|
||
case '\\':
|
||
c = skip_white_space (c);
|
||
default:
|
||
goto found_nonwhite;
|
||
}
|
||
found_nonwhite:
|
||
|
||
token_buffer[0] = c;
|
||
token_buffer[1] = 0;
|
||
|
||
/* yylloc.first_line = lineno; */
|
||
|
||
switch (c)
|
||
{
|
||
case EOF:
|
||
token_buffer[0] = '\0';
|
||
end_of_file = 1;
|
||
if (input_redirected ())
|
||
value = END_OF_SAVED_INPUT;
|
||
else if (linemode)
|
||
value = END_OF_LINE;
|
||
else if (do_pending_expansions ())
|
||
/* this will set yychar for us */
|
||
return yychar;
|
||
else
|
||
value = ENDFILE;
|
||
break;
|
||
|
||
case '$':
|
||
if (dollars_in_ident)
|
||
{
|
||
dollar_seen = 1;
|
||
goto letter;
|
||
}
|
||
value = '$';
|
||
goto done;
|
||
|
||
case 'L':
|
||
/* Capital L may start a wide-string or wide-character constant. */
|
||
{
|
||
register int c = getch ();
|
||
if (c == '\'')
|
||
{
|
||
wide_flag = 1;
|
||
goto char_constant;
|
||
}
|
||
if (c == '"')
|
||
{
|
||
wide_flag = 1;
|
||
goto string_constant;
|
||
}
|
||
put_back (c);
|
||
}
|
||
|
||
case 'A': case 'B': case 'C': case 'D': case 'E':
|
||
case 'F': case 'G': case 'H': case 'I': case 'J':
|
||
case 'K': case 'M': case 'N': case 'O':
|
||
case 'P': case 'Q': case 'R': case 'S': case 'T':
|
||
case 'U': case 'V': case 'W': case 'X': case 'Y':
|
||
case 'Z':
|
||
case 'a': case 'b': case 'c': case 'd': case 'e':
|
||
case 'f': case 'g': case 'h': case 'i': case 'j':
|
||
case 'k': case 'l': case 'm': case 'n': case 'o':
|
||
case 'p': case 'q': case 'r': case 's': case 't':
|
||
case 'u': case 'v': case 'w': case 'x': case 'y':
|
||
case 'z':
|
||
case '_':
|
||
letter:
|
||
{
|
||
register char *p;
|
||
|
||
p = token_buffer;
|
||
if (input == 0)
|
||
{
|
||
/* We know that `token_buffer' can hold at least on char,
|
||
so we install C immediately.
|
||
We may have to read the value in `putback_char', so call
|
||
`getch' once. */
|
||
*p++ = c;
|
||
c = getch ();
|
||
|
||
/* Make this run fast. We know that we are reading straight
|
||
from FINPUT in this case (since identifiers cannot straddle
|
||
input sources. */
|
||
while (isalnum (c) || (c == '_') || c == '$')
|
||
{
|
||
if (c == '$' && ! dollars_in_ident)
|
||
break;
|
||
if (p >= token_buffer + maxtoken)
|
||
p = extend_token_buffer (p);
|
||
|
||
*p++ = c;
|
||
c = getc (finput);
|
||
}
|
||
|
||
if (linemode && c == '\n')
|
||
{
|
||
put_back (c);
|
||
c = EOF;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* We know that `token_buffer' can hold at least on char,
|
||
so we install C immediately. */
|
||
*p++ = c;
|
||
c = getch ();
|
||
|
||
while (isalnum (c) || (c == '_') || c == '$')
|
||
{
|
||
if (c == '$' && ! dollars_in_ident)
|
||
break;
|
||
if (p >= token_buffer + maxtoken)
|
||
p = extend_token_buffer (p);
|
||
|
||
*p++ = c;
|
||
c = getch ();
|
||
}
|
||
}
|
||
|
||
*p = 0;
|
||
nextchar = c;
|
||
|
||
value = IDENTIFIER;
|
||
yylval.itype = 0;
|
||
|
||
/* Try to recognize a keyword. Uses minimum-perfect hash function */
|
||
|
||
{
|
||
register struct resword *ptr;
|
||
|
||
if (ptr = is_reserved_word (token_buffer, p - token_buffer))
|
||
{
|
||
if (ptr->rid)
|
||
{
|
||
tree old_ttype = ridpointers[(int) ptr->rid];
|
||
|
||
/* If this provides a type for us, then revert lexical
|
||
state to standard state. */
|
||
if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
|
||
&& IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
|
||
&& TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
|
||
looking_for_typename = 0;
|
||
else if (ptr->token == AGGR || ptr->token == ENUM)
|
||
looking_for_typename = 1;
|
||
|
||
/* Check if this is a language-type declaration.
|
||
Just glimpse the next non-white character. */
|
||
nextchar = skip_white_space (nextchar);
|
||
if (nextchar == '"')
|
||
{
|
||
/* We are looking at a string. Complain
|
||
if the token before the string is no `extern'.
|
||
|
||
Could cheat some memory by placing this string
|
||
on the temporary_, instead of the saveable_
|
||
obstack. */
|
||
|
||
if (ptr->rid != RID_EXTERN)
|
||
error ("invalid modifier `%s' for language string",
|
||
ptr->name);
|
||
real_yylex ();
|
||
value = EXTERN_LANG_STRING;
|
||
yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
|
||
break;
|
||
}
|
||
if (ptr->token == VISSPEC)
|
||
{
|
||
switch (ptr->rid)
|
||
{
|
||
case RID_PUBLIC:
|
||
yylval.itype = access_public;
|
||
break;
|
||
case RID_PRIVATE:
|
||
yylval.itype = access_private;
|
||
break;
|
||
case RID_PROTECTED:
|
||
yylval.itype = access_protected;
|
||
break;
|
||
default:
|
||
my_friendly_abort (63);
|
||
}
|
||
}
|
||
else
|
||
yylval.ttype = old_ttype;
|
||
}
|
||
else if (ptr->token == EQCOMPARE)
|
||
{
|
||
yylval.code = NE_EXPR;
|
||
token_buffer[0] = '!';
|
||
token_buffer[1] = '=';
|
||
token_buffer[2] = 0;
|
||
}
|
||
else if (ptr->token == ASSIGN)
|
||
{
|
||
if (strcmp ("and_eq", token_buffer) == 0)
|
||
{
|
||
yylval.code = BIT_AND_EXPR;
|
||
token_buffer[0] = '&';
|
||
}
|
||
else if (strcmp ("or_eq", token_buffer) == 0)
|
||
{
|
||
yylval.code = BIT_IOR_EXPR;
|
||
token_buffer[0] = '|';
|
||
}
|
||
else if (strcmp ("xor_eq", token_buffer) == 0)
|
||
{
|
||
yylval.code = BIT_XOR_EXPR;
|
||
token_buffer[0] = '^';
|
||
}
|
||
token_buffer[1] = '=';
|
||
token_buffer[2] = 0;
|
||
}
|
||
else if (ptr->token == '&')
|
||
{
|
||
yylval.code = BIT_AND_EXPR;
|
||
token_buffer[0] = '&';
|
||
token_buffer[1] = 0;
|
||
}
|
||
else if (ptr->token == '|')
|
||
{
|
||
yylval.code = BIT_IOR_EXPR;
|
||
token_buffer[0] = '|';
|
||
token_buffer[1] = 0;
|
||
}
|
||
else if (ptr->token == '^')
|
||
{
|
||
yylval.code = BIT_XOR_EXPR;
|
||
token_buffer[0] = '^';
|
||
token_buffer[1] = 0;
|
||
}
|
||
|
||
value = (int) ptr->token;
|
||
}
|
||
}
|
||
|
||
/* If we did not find a keyword, look for an identifier
|
||
(or a typename). */
|
||
|
||
if (strcmp ("catch", token_buffer) == 0
|
||
|| strcmp ("throw", token_buffer) == 0
|
||
|| strcmp ("try", token_buffer) == 0)
|
||
{
|
||
static int did_warn = 0;
|
||
if (! did_warn && ! flag_handle_exceptions)
|
||
{
|
||
pedwarn ("`catch', `throw', and `try' are all C++ reserved words");
|
||
did_warn = 1;
|
||
}
|
||
}
|
||
|
||
if (value == IDENTIFIER || value == TYPESPEC)
|
||
GNU_xref_ref (current_function_decl, token_buffer);
|
||
|
||
if (value == IDENTIFIER)
|
||
{
|
||
register tree tmp = get_identifier (token_buffer);
|
||
|
||
#if !defined(VMS) && defined(JOINER)
|
||
/* Make sure that user does not collide with our internal
|
||
naming scheme. */
|
||
if (JOINER == '$'
|
||
&& dollar_seen
|
||
&& (THIS_NAME_P (tmp)
|
||
|| VPTR_NAME_P (tmp)
|
||
|| DESTRUCTOR_NAME_P (tmp)
|
||
|| VTABLE_NAME_P (tmp)
|
||
|| TEMP_NAME_P (tmp)
|
||
|| ANON_AGGRNAME_P (tmp)
|
||
|| ANON_PARMNAME_P (tmp)))
|
||
warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
|
||
token_buffer);
|
||
#endif
|
||
|
||
yylval.ttype = tmp;
|
||
|
||
/* A user-invisible read-only initialized variable
|
||
should be replaced by its value. We only handle strings
|
||
since that's the only case used in C (and C++). */
|
||
/* Note we go right after the local value for the identifier
|
||
(e.g., __FUNCTION__ or __PRETTY_FUNCTION__). We used to
|
||
call lookup_name, but that could result in an error about
|
||
ambiguities. */
|
||
tmp = IDENTIFIER_LOCAL_VALUE (yylval.ttype);
|
||
if (tmp != NULL_TREE
|
||
&& TREE_CODE (tmp) == VAR_DECL
|
||
&& DECL_IGNORED_P (tmp)
|
||
&& TREE_READONLY (tmp)
|
||
&& DECL_INITIAL (tmp) != NULL_TREE
|
||
&& TREE_CODE (DECL_INITIAL (tmp)) == STRING_CST)
|
||
{
|
||
yylval.ttype = DECL_INITIAL (tmp);
|
||
value = STRING;
|
||
}
|
||
}
|
||
if (value == NEW && ! global_bindings_p ())
|
||
{
|
||
value = NEW;
|
||
goto done;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case '.':
|
||
{
|
||
register int c1 = getch ();
|
||
token_buffer[0] = c;
|
||
token_buffer[1] = c1;
|
||
if (c1 == '*')
|
||
{
|
||
value = DOT_STAR;
|
||
token_buffer[2] = 0;
|
||
goto done;
|
||
}
|
||
if (c1 == '.')
|
||
{
|
||
c1 = getch ();
|
||
if (c1 == '.')
|
||
{
|
||
token_buffer[2] = c1;
|
||
token_buffer[3] = 0;
|
||
value = ELLIPSIS;
|
||
goto done;
|
||
}
|
||
error ("parse error at `..'");
|
||
}
|
||
if (isdigit (c1))
|
||
{
|
||
put_back (c1);
|
||
goto resume_numerical_scan;
|
||
}
|
||
nextchar = c1;
|
||
value = '.';
|
||
token_buffer[1] = 0;
|
||
goto done;
|
||
}
|
||
case '0': case '1':
|
||
/* Optimize for most frequent case. */
|
||
{
|
||
register int c1 = getch ();
|
||
if (! isalnum (c1) && c1 != '.')
|
||
{
|
||
/* Terminate string. */
|
||
token_buffer[0] = c;
|
||
token_buffer[1] = 0;
|
||
if (c == '0')
|
||
yylval.ttype = integer_zero_node;
|
||
else
|
||
yylval.ttype = integer_one_node;
|
||
nextchar = c1;
|
||
value = CONSTANT;
|
||
goto done;
|
||
}
|
||
put_back (c1);
|
||
}
|
||
/* fall through... */
|
||
case '2': case '3': case '4':
|
||
case '5': case '6': case '7': case '8': case '9':
|
||
resume_numerical_scan:
|
||
{
|
||
register char *p;
|
||
int base = 10;
|
||
int count = 0;
|
||
int largest_digit = 0;
|
||
int numdigits = 0;
|
||
/* for multi-precision arithmetic,
|
||
we actually store only HOST_BITS_PER_CHAR bits in each part.
|
||
The number of parts is chosen so as to be sufficient to hold
|
||
the enough bits to fit into the two HOST_WIDE_INTs that contain
|
||
the integer value (this is always at least as many bits as are
|
||
in a target `long long' value, but may be wider). */
|
||
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
|
||
int parts[TOTAL_PARTS];
|
||
int overflow = 0;
|
||
|
||
enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
|
||
= NOT_FLOAT;
|
||
|
||
p = token_buffer;
|
||
*p++ = c;
|
||
|
||
for (count = 0; count < TOTAL_PARTS; count++)
|
||
parts[count] = 0;
|
||
|
||
if (c == '0')
|
||
{
|
||
*p++ = (c = getch ());
|
||
if ((c == 'x') || (c == 'X'))
|
||
{
|
||
base = 16;
|
||
*p++ = (c = getch ());
|
||
}
|
||
/* Leading 0 forces octal unless the 0 is the only digit. */
|
||
else if (c >= '0' && c <= '9')
|
||
{
|
||
base = 8;
|
||
numdigits++;
|
||
}
|
||
else
|
||
numdigits++;
|
||
}
|
||
|
||
/* Read all the digits-and-decimal-points. */
|
||
|
||
while (c == '.'
|
||
|| (isalnum (c) && (c != 'l') && (c != 'L')
|
||
&& (c != 'u') && (c != 'U')
|
||
&& (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
|
||
{
|
||
if (c == '.')
|
||
{
|
||
if (base == 16)
|
||
error ("floating constant may not be in radix 16");
|
||
if (floatflag == AFTER_POINT)
|
||
{
|
||
error ("malformed floating constant");
|
||
floatflag = TOO_MANY_POINTS;
|
||
}
|
||
else
|
||
floatflag = AFTER_POINT;
|
||
|
||
base = 10;
|
||
*p++ = c = getch ();
|
||
/* Accept '.' as the start of a floating-point number
|
||
only when it is followed by a digit.
|
||
Otherwise, unread the following non-digit
|
||
and use the '.' as a structural token. */
|
||
if (p == token_buffer + 2 && !isdigit (c))
|
||
{
|
||
if (c == '.')
|
||
{
|
||
c = getch ();
|
||
if (c == '.')
|
||
{
|
||
*p++ = '.';
|
||
*p = '\0';
|
||
value = ELLIPSIS;
|
||
goto done;
|
||
}
|
||
error ("parse error at `..'");
|
||
}
|
||
nextchar = c;
|
||
token_buffer[1] = '\0';
|
||
value = '.';
|
||
goto done;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* It is not a decimal point.
|
||
It should be a digit (perhaps a hex digit). */
|
||
|
||
if (isdigit (c))
|
||
{
|
||
c = c - '0';
|
||
}
|
||
else if (base <= 10)
|
||
{
|
||
if (c == 'e' || c == 'E')
|
||
{
|
||
base = 10;
|
||
floatflag = AFTER_POINT;
|
||
break; /* start of exponent */
|
||
}
|
||
error ("nondigits in number and not hexadecimal");
|
||
c = 0;
|
||
}
|
||
else if (c >= 'a')
|
||
{
|
||
c = c - 'a' + 10;
|
||
}
|
||
else
|
||
{
|
||
c = c - 'A' + 10;
|
||
}
|
||
if (c >= largest_digit)
|
||
largest_digit = c;
|
||
numdigits++;
|
||
|
||
for (count = 0; count < TOTAL_PARTS; count++)
|
||
{
|
||
parts[count] *= base;
|
||
if (count)
|
||
{
|
||
parts[count]
|
||
+= (parts[count-1] >> HOST_BITS_PER_CHAR);
|
||
parts[count-1]
|
||
&= (1 << HOST_BITS_PER_CHAR) - 1;
|
||
}
|
||
else
|
||
parts[0] += c;
|
||
}
|
||
|
||
/* If the extra highest-order part ever gets anything in it,
|
||
the number is certainly too big. */
|
||
if (parts[TOTAL_PARTS - 1] != 0)
|
||
overflow = 1;
|
||
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = (c = getch ());
|
||
}
|
||
}
|
||
|
||
if (numdigits == 0)
|
||
error ("numeric constant with no digits");
|
||
|
||
if (largest_digit >= base)
|
||
error ("numeric constant contains digits beyond the radix");
|
||
|
||
/* Remove terminating char from the token buffer and delimit the string */
|
||
*--p = 0;
|
||
|
||
if (floatflag != NOT_FLOAT)
|
||
{
|
||
tree type = double_type_node;
|
||
char f_seen = 0;
|
||
char l_seen = 0;
|
||
int garbage_chars = 0;
|
||
REAL_VALUE_TYPE value;
|
||
jmp_buf handler;
|
||
|
||
/* Read explicit exponent if any, and put it in tokenbuf. */
|
||
|
||
if ((c == 'e') || (c == 'E'))
|
||
{
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = getch ();
|
||
if ((c == '+') || (c == '-'))
|
||
{
|
||
*p++ = c;
|
||
c = getch ();
|
||
}
|
||
if (! isdigit (c))
|
||
error ("floating constant exponent has no digits");
|
||
while (isdigit (c))
|
||
{
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = getch ();
|
||
}
|
||
}
|
||
|
||
*p = 0;
|
||
errno = 0;
|
||
|
||
/* Convert string to a double, checking for overflow. */
|
||
if (setjmp (handler))
|
||
{
|
||
error ("floating constant out of range");
|
||
value = dconst0;
|
||
}
|
||
else
|
||
{
|
||
set_float_handler (handler);
|
||
/* The second argument, machine_mode, of REAL_VALUE_ATOF
|
||
tells the desired precision of the binary result of
|
||
decimal-to-binary conversion. */
|
||
|
||
/* Read the suffixes to choose a data type. */
|
||
switch (c)
|
||
{
|
||
case 'f': case 'F':
|
||
type = float_type_node;
|
||
value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
|
||
garbage_chars = -1;
|
||
break;
|
||
|
||
case 'l': case 'L':
|
||
type = long_double_type_node;
|
||
value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
|
||
garbage_chars = -1;
|
||
break;
|
||
|
||
default:
|
||
value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
|
||
}
|
||
set_float_handler (NULL_PTR);
|
||
}
|
||
if (pedantic
|
||
&& (REAL_VALUE_ISINF (value)
|
||
#ifdef ERANGE
|
||
|| (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
|
||
&& errno == ERANGE
|
||
/* ERANGE is also reported for underflow, so test the
|
||
value to distinguish overflow from that. */
|
||
&& (REAL_VALUES_LESS (dconst1, value)
|
||
|| REAL_VALUES_LESS (value, dconstm1)))
|
||
#endif
|
||
))
|
||
{
|
||
pedwarn ("floating point number exceeds range of `%s'",
|
||
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
|
||
}
|
||
/* Note: garbage_chars is -1 if first char is *not* garbage. */
|
||
while (isalnum (c))
|
||
{
|
||
if (c == 'f' || c == 'F')
|
||
{
|
||
if (f_seen)
|
||
error ("two `f's in floating constant");
|
||
f_seen = 1;
|
||
}
|
||
if (c == 'l' || c == 'L')
|
||
{
|
||
if (l_seen)
|
||
error ("two `l's in floating constant");
|
||
l_seen = 1;
|
||
}
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = getch ();
|
||
garbage_chars++;
|
||
}
|
||
|
||
if (garbage_chars > 0)
|
||
error ("garbage at end of number");
|
||
|
||
/* Create a node with determined type and value. */
|
||
yylval.ttype = build_real (type, value);
|
||
|
||
put_back (c);
|
||
*p = 0;
|
||
}
|
||
else
|
||
{
|
||
tree type;
|
||
HOST_WIDE_INT high, low;
|
||
int spec_unsigned = 0;
|
||
int spec_long = 0;
|
||
int spec_long_long = 0;
|
||
int bytes, warn;
|
||
|
||
while (1)
|
||
{
|
||
if (c == 'u' || c == 'U')
|
||
{
|
||
if (spec_unsigned)
|
||
error ("two `u's in integer constant");
|
||
spec_unsigned = 1;
|
||
}
|
||
else if (c == 'l' || c == 'L')
|
||
{
|
||
if (spec_long)
|
||
{
|
||
if (spec_long_long)
|
||
error ("three `l's in integer constant");
|
||
else if (pedantic)
|
||
pedwarn ("ANSI C++ forbids long long integer constants");
|
||
spec_long_long = 1;
|
||
}
|
||
spec_long = 1;
|
||
}
|
||
else
|
||
{
|
||
if (isalnum (c))
|
||
{
|
||
error ("garbage at end of number");
|
||
while (isalnum (c))
|
||
{
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = getch ();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = getch ();
|
||
}
|
||
|
||
put_back (c);
|
||
|
||
/* If the constant is not long long and it won't fit in an
|
||
unsigned long, or if the constant is long long and won't fit
|
||
in an unsigned long long, then warn that the constant is out
|
||
of range. */
|
||
|
||
/* ??? This assumes that long long and long integer types are
|
||
a multiple of 8 bits. This better than the original code
|
||
though which assumed that long was exactly 32 bits and long
|
||
long was exactly 64 bits. */
|
||
|
||
if (spec_long_long)
|
||
bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
|
||
else
|
||
bytes = TYPE_PRECISION (long_integer_type_node) / 8;
|
||
|
||
warn = overflow;
|
||
for (i = bytes; i < TOTAL_PARTS; i++)
|
||
if (parts[i])
|
||
warn = 1;
|
||
if (warn)
|
||
pedwarn ("integer constant out of range");
|
||
|
||
/* This is simplified by the fact that our constant
|
||
is always positive. */
|
||
high = low = 0;
|
||
|
||
for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
|
||
{
|
||
high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
|
||
/ HOST_BITS_PER_CHAR)]
|
||
<< (i * HOST_BITS_PER_CHAR));
|
||
low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
|
||
}
|
||
|
||
|
||
yylval.ttype = build_int_2 (low, high);
|
||
TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
|
||
|
||
#if 0
|
||
/* Find the first allowable type that the value fits in. */
|
||
type = 0;
|
||
for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
|
||
i++)
|
||
if (!(spec_long && !type_sequence[i].long_flag)
|
||
&& !(spec_long_long && !type_sequence[i].long_long_flag)
|
||
&& !(spec_unsigned && !type_sequence[i].unsigned_flag)
|
||
/* A hex or octal constant traditionally is unsigned. */
|
||
&& !(base != 10 && flag_traditional
|
||
&& !type_sequence[i].unsigned_flag)
|
||
/* A decimal constant can't be unsigned int
|
||
unless explicitly specified. */
|
||
&& !(base == 10 && !spec_unsigned
|
||
&& *type_sequence[i].node_var == unsigned_type_node))
|
||
if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
|
||
{
|
||
type = *type_sequence[i].node_var;
|
||
break;
|
||
}
|
||
if (flag_traditional && type == long_unsigned_type_node
|
||
&& !spec_unsigned)
|
||
type = long_integer_type_node;
|
||
|
||
if (type == 0)
|
||
{
|
||
type = long_long_integer_type_node;
|
||
warning ("integer constant out of range");
|
||
}
|
||
|
||
/* Warn about some cases where the type of a given constant
|
||
changes from traditional C to ANSI C. */
|
||
if (warn_traditional)
|
||
{
|
||
tree other_type = 0;
|
||
|
||
/* This computation is the same as the previous one
|
||
except that flag_traditional is used backwards. */
|
||
for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
|
||
i++)
|
||
if (!(spec_long && !type_sequence[i].long_flag)
|
||
&& !(spec_long_long && !type_sequence[i].long_long_flag)
|
||
&& !(spec_unsigned && !type_sequence[i].unsigned_flag)
|
||
/* A hex or octal constant traditionally is unsigned. */
|
||
&& !(base != 10 && !flag_traditional
|
||
&& !type_sequence[i].unsigned_flag)
|
||
/* A decimal constant can't be unsigned int
|
||
unless explicitly specified. */
|
||
&& !(base == 10 && !spec_unsigned
|
||
&& *type_sequence[i].node_var == unsigned_type_node))
|
||
if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
|
||
{
|
||
other_type = *type_sequence[i].node_var;
|
||
break;
|
||
}
|
||
if (!flag_traditional && type == long_unsigned_type_node
|
||
&& !spec_unsigned)
|
||
type = long_integer_type_node;
|
||
|
||
if (other_type != 0 && other_type != type)
|
||
{
|
||
if (flag_traditional)
|
||
warning ("type of integer constant would be different without -traditional");
|
||
else
|
||
warning ("type of integer constant would be different with -traditional");
|
||
}
|
||
}
|
||
|
||
#else /* 1 */
|
||
if (!spec_long && !spec_unsigned
|
||
&& !(flag_traditional && base != 10)
|
||
&& int_fits_type_p (yylval.ttype, integer_type_node))
|
||
{
|
||
#if 0
|
||
if (warn_traditional && base != 10)
|
||
warning ("small nondecimal constant becomes signed in ANSI C++");
|
||
#endif
|
||
type = integer_type_node;
|
||
}
|
||
else if (!spec_long && (base != 10 || spec_unsigned)
|
||
&& int_fits_type_p (yylval.ttype, unsigned_type_node))
|
||
{
|
||
/* Nondecimal constants try unsigned even in traditional C. */
|
||
type = unsigned_type_node;
|
||
}
|
||
|
||
else if (!spec_unsigned && !spec_long_long
|
||
&& int_fits_type_p (yylval.ttype, long_integer_type_node))
|
||
type = long_integer_type_node;
|
||
|
||
else if (! spec_long_long
|
||
&& int_fits_type_p (yylval.ttype,
|
||
long_unsigned_type_node))
|
||
{
|
||
#if 0
|
||
if (warn_traditional && !spec_unsigned)
|
||
warning ("large integer constant becomes unsigned in ANSI C++");
|
||
#endif
|
||
if (flag_traditional && !spec_unsigned)
|
||
type = long_integer_type_node;
|
||
else
|
||
type = long_unsigned_type_node;
|
||
}
|
||
|
||
else if (! spec_unsigned
|
||
/* Verify value does not overflow into sign bit. */
|
||
&& TREE_INT_CST_HIGH (yylval.ttype) >= 0
|
||
&& int_fits_type_p (yylval.ttype,
|
||
long_long_integer_type_node))
|
||
type = long_long_integer_type_node;
|
||
|
||
else if (int_fits_type_p (yylval.ttype,
|
||
long_long_unsigned_type_node))
|
||
{
|
||
#if 0
|
||
if (warn_traditional && !spec_unsigned)
|
||
warning ("large nondecimal constant is unsigned in ANSI C++");
|
||
#endif
|
||
|
||
if (flag_traditional && !spec_unsigned)
|
||
type = long_long_integer_type_node;
|
||
else
|
||
type = long_long_unsigned_type_node;
|
||
}
|
||
|
||
else
|
||
{
|
||
type = long_long_integer_type_node;
|
||
warning ("integer constant out of range");
|
||
|
||
if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
|
||
warning ("decimal integer constant is so large that it is unsigned");
|
||
}
|
||
#endif
|
||
|
||
TREE_TYPE (yylval.ttype) = type;
|
||
*p = 0;
|
||
}
|
||
|
||
value = CONSTANT; break;
|
||
}
|
||
|
||
case '\'':
|
||
char_constant:
|
||
{
|
||
register int result = 0;
|
||
register int num_chars = 0;
|
||
unsigned width = TYPE_PRECISION (char_type_node);
|
||
int max_chars;
|
||
|
||
if (wide_flag)
|
||
{
|
||
width = WCHAR_TYPE_SIZE;
|
||
#ifdef MULTIBYTE_CHARS
|
||
max_chars = MB_CUR_MAX;
|
||
#else
|
||
max_chars = 1;
|
||
#endif
|
||
}
|
||
else
|
||
max_chars = TYPE_PRECISION (integer_type_node) / width;
|
||
|
||
while (1)
|
||
{
|
||
tryagain:
|
||
|
||
c = getch ();
|
||
|
||
if (c == '\'' || c == EOF)
|
||
break;
|
||
|
||
if (c == '\\')
|
||
{
|
||
int ignore = 0;
|
||
c = readescape (&ignore);
|
||
if (ignore)
|
||
goto tryagain;
|
||
if (width < HOST_BITS_PER_INT
|
||
&& (unsigned) c >= (1 << width))
|
||
warning ("escape sequence out of range for character");
|
||
#ifdef MAP_CHARACTER
|
||
if (isprint (c))
|
||
c = MAP_CHARACTER (c);
|
||
#endif
|
||
}
|
||
else if (c == '\n')
|
||
{
|
||
if (pedantic)
|
||
pedwarn ("ANSI C++ forbids newline in character constant");
|
||
lineno++;
|
||
}
|
||
#ifdef MAP_CHARACTER
|
||
else
|
||
c = MAP_CHARACTER (c);
|
||
#endif
|
||
|
||
num_chars++;
|
||
if (num_chars > maxtoken - 4)
|
||
extend_token_buffer (token_buffer);
|
||
|
||
token_buffer[num_chars] = c;
|
||
|
||
/* Merge character into result; ignore excess chars. */
|
||
if (num_chars < max_chars + 1)
|
||
{
|
||
if (width < HOST_BITS_PER_INT)
|
||
result = (result << width) | (c & ((1 << width) - 1));
|
||
else
|
||
result = c;
|
||
}
|
||
}
|
||
|
||
token_buffer[num_chars + 1] = '\'';
|
||
token_buffer[num_chars + 2] = 0;
|
||
|
||
if (c != '\'')
|
||
error ("malformatted character constant");
|
||
else if (num_chars == 0)
|
||
error ("empty character constant");
|
||
else if (num_chars > max_chars)
|
||
{
|
||
num_chars = max_chars;
|
||
error ("character constant too long");
|
||
}
|
||
else if (num_chars != 1 && ! flag_traditional)
|
||
warning ("multi-character character constant");
|
||
|
||
/* If char type is signed, sign-extend the constant. */
|
||
if (! wide_flag)
|
||
{
|
||
int num_bits = num_chars * width;
|
||
if (num_bits == 0)
|
||
/* We already got an error; avoid invalid shift. */
|
||
yylval.ttype = build_int_2 (0, 0);
|
||
else if (TREE_UNSIGNED (char_type_node)
|
||
|| ((result >> (num_bits - 1)) & 1) == 0)
|
||
yylval.ttype
|
||
= build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
|
||
>> (HOST_BITS_PER_WIDE_INT - num_bits)),
|
||
0);
|
||
else
|
||
yylval.ttype
|
||
= build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
|
||
>> (HOST_BITS_PER_WIDE_INT - num_bits)),
|
||
-1);
|
||
if (num_chars<=1)
|
||
TREE_TYPE (yylval.ttype) = char_type_node;
|
||
else
|
||
TREE_TYPE (yylval.ttype) = integer_type_node;
|
||
}
|
||
else
|
||
{
|
||
#ifdef MULTIBYTE_CHARS
|
||
/* Set the initial shift state and convert the next sequence. */
|
||
result = 0;
|
||
/* In all locales L'\0' is zero and mbtowc will return zero,
|
||
so don't use it. */
|
||
if (num_chars > 1
|
||
|| (num_chars == 1 && token_buffer[1] != '\0'))
|
||
{
|
||
wchar_t wc;
|
||
(void) mbtowc (NULL, NULL, 0);
|
||
if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
|
||
result = wc;
|
||
else
|
||
warning ("Ignoring invalid multibyte character");
|
||
}
|
||
#endif
|
||
yylval.ttype = build_int_2 (result, 0);
|
||
TREE_TYPE (yylval.ttype) = wchar_type_node;
|
||
}
|
||
|
||
value = CONSTANT;
|
||
break;
|
||
}
|
||
|
||
case '"':
|
||
string_constant:
|
||
{
|
||
register char *p;
|
||
|
||
c = getch ();
|
||
p = token_buffer + 1;
|
||
|
||
while (c != '"' && c >= 0)
|
||
{
|
||
/* ignore_escape_flag is set for reading the filename in #line. */
|
||
if (!ignore_escape_flag && c == '\\')
|
||
{
|
||
int ignore = 0;
|
||
c = readescape (&ignore);
|
||
if (ignore)
|
||
goto skipnewline;
|
||
if (!wide_flag
|
||
&& TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
|
||
&& c >= ((unsigned) 1 << TYPE_PRECISION (char_type_node)))
|
||
warning ("escape sequence out of range for character");
|
||
}
|
||
else if (c == '\n')
|
||
{
|
||
if (pedantic)
|
||
pedwarn ("ANSI C++ forbids newline in string constant");
|
||
lineno++;
|
||
}
|
||
|
||
if (p == token_buffer + maxtoken)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
|
||
skipnewline:
|
||
c = getch ();
|
||
if (c == EOF) {
|
||
error("Unterminated string");
|
||
break;
|
||
}
|
||
}
|
||
*p = 0;
|
||
|
||
/* We have read the entire constant.
|
||
Construct a STRING_CST for the result. */
|
||
|
||
if (wide_flag)
|
||
{
|
||
/* If this is a L"..." wide-string, convert the multibyte string
|
||
to a wide character string. */
|
||
char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
|
||
int len;
|
||
|
||
#ifdef MULTIBYTE_CHARS
|
||
len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
|
||
if (len < 0 || len >= (p - token_buffer))
|
||
{
|
||
warning ("Ignoring invalid multibyte string");
|
||
len = 0;
|
||
}
|
||
bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
|
||
#else
|
||
{
|
||
union { long l; char c[sizeof (long)]; } u;
|
||
int big_endian;
|
||
char *wp, *cp;
|
||
|
||
/* Determine whether host is little or big endian. */
|
||
u.l = 1;
|
||
big_endian = u.c[sizeof (long) - 1];
|
||
wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
|
||
|
||
bzero (widep, (p - token_buffer) * WCHAR_BYTES);
|
||
for (cp = token_buffer + 1; cp < p; cp++)
|
||
*wp = *cp, wp += WCHAR_BYTES;
|
||
len = p - token_buffer - 1;
|
||
}
|
||
#endif
|
||
yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
|
||
TREE_TYPE (yylval.ttype) = wchar_array_type_node;
|
||
}
|
||
else
|
||
{
|
||
yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
|
||
TREE_TYPE (yylval.ttype) = char_array_type_node;
|
||
}
|
||
|
||
*p++ = '"';
|
||
*p = 0;
|
||
|
||
value = STRING; break;
|
||
}
|
||
|
||
case '+':
|
||
case '-':
|
||
case '&':
|
||
case '|':
|
||
case '<':
|
||
case '>':
|
||
case '*':
|
||
case '/':
|
||
case '%':
|
||
case '^':
|
||
case '!':
|
||
case '=':
|
||
{
|
||
register int c1;
|
||
|
||
combine:
|
||
|
||
switch (c)
|
||
{
|
||
case '+':
|
||
yylval.code = PLUS_EXPR; break;
|
||
case '-':
|
||
yylval.code = MINUS_EXPR; break;
|
||
case '&':
|
||
yylval.code = BIT_AND_EXPR; break;
|
||
case '|':
|
||
yylval.code = BIT_IOR_EXPR; break;
|
||
case '*':
|
||
yylval.code = MULT_EXPR; break;
|
||
case '/':
|
||
yylval.code = TRUNC_DIV_EXPR; break;
|
||
case '%':
|
||
yylval.code = TRUNC_MOD_EXPR; break;
|
||
case '^':
|
||
yylval.code = BIT_XOR_EXPR; break;
|
||
case LSHIFT:
|
||
yylval.code = LSHIFT_EXPR; break;
|
||
case RSHIFT:
|
||
yylval.code = RSHIFT_EXPR; break;
|
||
case '<':
|
||
yylval.code = LT_EXPR; break;
|
||
case '>':
|
||
yylval.code = GT_EXPR; break;
|
||
}
|
||
|
||
token_buffer[1] = c1 = getch ();
|
||
token_buffer[2] = 0;
|
||
|
||
if (c1 == '=')
|
||
{
|
||
switch (c)
|
||
{
|
||
case '<':
|
||
value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
|
||
case '>':
|
||
value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
|
||
case '!':
|
||
value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
|
||
case '=':
|
||
value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
|
||
}
|
||
value = ASSIGN; goto done;
|
||
}
|
||
else if (c == c1)
|
||
switch (c)
|
||
{
|
||
case '+':
|
||
value = PLUSPLUS; goto done;
|
||
case '-':
|
||
value = MINUSMINUS; goto done;
|
||
case '&':
|
||
value = ANDAND; goto done;
|
||
case '|':
|
||
value = OROR; goto done;
|
||
case '<':
|
||
c = LSHIFT;
|
||
goto combine;
|
||
case '>':
|
||
c = RSHIFT;
|
||
goto combine;
|
||
}
|
||
else if ((c == '-') && (c1 == '>'))
|
||
{
|
||
nextchar = getch ();
|
||
if (nextchar == '*')
|
||
{
|
||
nextchar = -1;
|
||
value = POINTSAT_STAR;
|
||
}
|
||
else
|
||
value = POINTSAT;
|
||
goto done;
|
||
}
|
||
else if (c1 == '?' && (c == '<' || c == '>'))
|
||
{
|
||
token_buffer[3] = 0;
|
||
|
||
c1 = getch ();
|
||
yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
|
||
if (c1 == '=')
|
||
{
|
||
/* <?= or >?= expression. */
|
||
token_buffer[2] = c1;
|
||
value = ASSIGN;
|
||
}
|
||
else
|
||
{
|
||
value = MIN_MAX;
|
||
nextchar = c1;
|
||
}
|
||
if (pedantic)
|
||
pedwarn ("use of `operator %s' is not standard C++",
|
||
token_buffer);
|
||
goto done;
|
||
}
|
||
/* digraphs */
|
||
else if (c == '<' && c1 == '%')
|
||
{ value = '{'; goto done; }
|
||
else if (c == '<' && c1 == ':')
|
||
{ value = '['; goto done; }
|
||
else if (c == '%' && c1 == '>')
|
||
{ value = '}'; goto done; }
|
||
else if (c == '%' && c1 == ':')
|
||
{ value = '#'; goto done; }
|
||
|
||
nextchar = c1;
|
||
token_buffer[1] = 0;
|
||
|
||
value = c;
|
||
goto done;
|
||
}
|
||
|
||
case ':':
|
||
c = getch ();
|
||
if (c == ':')
|
||
{
|
||
token_buffer[1] = ':';
|
||
token_buffer[2] = '\0';
|
||
value = SCOPE;
|
||
yylval.itype = 1;
|
||
}
|
||
else if (c == '>')
|
||
{
|
||
value = ']';
|
||
goto done;
|
||
}
|
||
else
|
||
{
|
||
nextchar = c;
|
||
value = ':';
|
||
}
|
||
break;
|
||
|
||
case 0:
|
||
/* Don't make yyparse think this is eof. */
|
||
value = 1;
|
||
break;
|
||
|
||
case '(':
|
||
/* try, weakly, to handle casts to pointers to functions. */
|
||
nextchar = skip_white_space (getch ());
|
||
if (nextchar == '*')
|
||
{
|
||
int next_c = skip_white_space (getch ());
|
||
if (next_c == ')')
|
||
{
|
||
nextchar = -1;
|
||
yylval.ttype = build1 (INDIRECT_REF, 0, 0);
|
||
value = PAREN_STAR_PAREN;
|
||
}
|
||
else
|
||
{
|
||
put_back (next_c);
|
||
value = c;
|
||
}
|
||
}
|
||
else if (nextchar == ')')
|
||
{
|
||
nextchar = -1;
|
||
yylval.ttype = NULL_TREE;
|
||
value = LEFT_RIGHT;
|
||
}
|
||
else value = c;
|
||
break;
|
||
|
||
default:
|
||
value = c;
|
||
}
|
||
|
||
done:
|
||
/* yylloc.last_line = lineno; */
|
||
#ifdef GATHER_STATISTICS
|
||
token_count[value] += 1;
|
||
#endif
|
||
|
||
return value;
|
||
}
|
||
|
||
typedef enum
|
||
{
|
||
d_kind, t_kind, s_kind, r_kind, e_kind, c_kind,
|
||
id_kind, op_id_kind, perm_list_kind, temp_list_kind,
|
||
vec_kind, x_kind, lang_decl, lang_type, all_kinds
|
||
} tree_node_kind;
|
||
extern int tree_node_counts[];
|
||
extern int tree_node_sizes[];
|
||
extern char *tree_node_kind_names[];
|
||
|
||
/* Place to save freed lang_decls which were allocated on the
|
||
permanent_obstack. @@ Not currently used. */
|
||
tree free_lang_decl_chain;
|
||
|
||
tree
|
||
build_lang_decl (code, name, type)
|
||
enum tree_code code;
|
||
tree name;
|
||
tree type;
|
||
{
|
||
register tree t = build_decl (code, name, type);
|
||
struct obstack *obstack = current_obstack;
|
||
register int i = sizeof (struct lang_decl) / sizeof (int);
|
||
register int *pi;
|
||
|
||
if (! TREE_PERMANENT (t))
|
||
obstack = saveable_obstack;
|
||
else
|
||
/* Could be that saveable is permanent and current is not. */
|
||
obstack = &permanent_obstack;
|
||
|
||
if (free_lang_decl_chain && obstack == &permanent_obstack)
|
||
{
|
||
pi = (int *)free_lang_decl_chain;
|
||
free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
|
||
}
|
||
else
|
||
pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
|
||
|
||
while (i > 0)
|
||
pi[--i] = 0;
|
||
|
||
DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
|
||
LANG_DECL_PERMANENT ((struct lang_decl *) pi)
|
||
= obstack == &permanent_obstack;
|
||
my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
|
||
== TREE_PERMANENT (t), 234);
|
||
DECL_MAIN_VARIANT (t) = t;
|
||
if (current_lang_name == lang_name_cplusplus)
|
||
{
|
||
DECL_LANGUAGE (t) = lang_cplusplus;
|
||
#if 0
|
||
#ifndef NO_AUTO_OVERLOAD
|
||
if (code == FUNCTION_DECL && name != 0
|
||
&& ! (IDENTIFIER_LENGTH (name) == 4
|
||
&& IDENTIFIER_POINTER (name)[0] == 'm'
|
||
&& strcmp (IDENTIFIER_POINTER (name), "main") == 0)
|
||
&& ! (IDENTIFIER_LENGTH (name) > 10
|
||
&& IDENTIFIER_POINTER (name)[0] == '_'
|
||
&& IDENTIFIER_POINTER (name)[1] == '_'
|
||
&& strncmp (IDENTIFIER_POINTER (name)+2, "builtin_", 8) == 0))
|
||
TREE_OVERLOADED (name) = 1;
|
||
#endif
|
||
#endif
|
||
}
|
||
else if (current_lang_name == lang_name_c)
|
||
DECL_LANGUAGE (t) = lang_c;
|
||
else my_friendly_abort (64);
|
||
|
||
#if 0 /* not yet, should get fixed properly later */
|
||
if (code == TYPE_DECL)
|
||
{
|
||
tree id;
|
||
id = get_identifier (build_overload_name (type, 1, 1));
|
||
DECL_ASSEMBLER_NAME (t) = id;
|
||
}
|
||
|
||
#endif
|
||
#ifdef GATHER_STATISTICS
|
||
tree_node_counts[(int)lang_decl] += 1;
|
||
tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
|
||
#endif
|
||
|
||
return t;
|
||
}
|
||
|
||
tree
|
||
build_lang_field_decl (code, name, type)
|
||
enum tree_code code;
|
||
tree name;
|
||
tree type;
|
||
{
|
||
extern struct obstack *current_obstack, *saveable_obstack;
|
||
register tree t = build_decl (code, name, type);
|
||
struct obstack *obstack = current_obstack;
|
||
register int i = sizeof (struct lang_decl_flags) / sizeof (int);
|
||
register int *pi;
|
||
#if 0 /* not yet, should get fixed properly later */
|
||
|
||
if (code == TYPE_DECL)
|
||
{
|
||
tree id;
|
||
id = get_identifier (build_overload_name (type, 1, 1));
|
||
DECL_ASSEMBLER_NAME (t) = id;
|
||
}
|
||
#endif
|
||
|
||
if (! TREE_PERMANENT (t))
|
||
obstack = saveable_obstack;
|
||
else
|
||
my_friendly_assert (obstack == &permanent_obstack, 235);
|
||
|
||
pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
|
||
while (i > 0)
|
||
pi[--i] = 0;
|
||
|
||
DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
|
||
return t;
|
||
}
|
||
|
||
void
|
||
copy_lang_decl (node)
|
||
tree node;
|
||
{
|
||
int size;
|
||
int *pi;
|
||
|
||
if (TREE_CODE (node) == FIELD_DECL)
|
||
size = sizeof (struct lang_decl_flags);
|
||
else
|
||
size = sizeof (struct lang_decl);
|
||
pi = (int *)obstack_alloc (&permanent_obstack, size);
|
||
bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
|
||
DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
|
||
}
|
||
|
||
tree
|
||
make_lang_type (code)
|
||
enum tree_code code;
|
||
{
|
||
extern struct obstack *current_obstack, *saveable_obstack;
|
||
register tree t = make_node (code);
|
||
struct obstack *obstack = current_obstack;
|
||
register int i = sizeof (struct lang_type) / sizeof (int);
|
||
register int *pi;
|
||
|
||
/* Set up some flags that give proper default behavior. */
|
||
IS_AGGR_TYPE (t) = 1;
|
||
|
||
if (! TREE_PERMANENT (t))
|
||
obstack = saveable_obstack;
|
||
else
|
||
my_friendly_assert (obstack == &permanent_obstack, 236);
|
||
|
||
pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
|
||
while (i > 0)
|
||
pi[--i] = 0;
|
||
|
||
TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
|
||
CLASSTYPE_AS_LIST (t) = build_tree_list (NULL_TREE, t);
|
||
SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
|
||
CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
|
||
CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
|
||
TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE,
|
||
NULL_TREE);
|
||
CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
|
||
|
||
/* Make sure this is laid out, for ease of use later.
|
||
In the presence of parse errors, the normal was of assuring
|
||
this might not ever get executed, so we lay it out *immediately*. */
|
||
build_pointer_type (t);
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
tree_node_counts[(int)lang_type] += 1;
|
||
tree_node_sizes[(int)lang_type] += sizeof(struct lang_type);
|
||
#endif
|
||
|
||
return t;
|
||
}
|
||
|
||
void
|
||
copy_decl_lang_specific (decl)
|
||
tree decl;
|
||
{
|
||
extern struct obstack *current_obstack, *saveable_obstack;
|
||
register int *old = (int *)DECL_LANG_SPECIFIC (decl);
|
||
struct obstack *obstack = current_obstack;
|
||
register int i = sizeof (struct lang_decl) / sizeof (int);
|
||
register int *pi;
|
||
|
||
if (! TREE_PERMANENT (decl))
|
||
obstack = saveable_obstack;
|
||
else
|
||
my_friendly_assert (obstack == &permanent_obstack, 237);
|
||
|
||
pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
|
||
while (i-- > 0)
|
||
pi[i] = old[i];
|
||
|
||
DECL_LANG_SPECIFIC (decl) = (struct lang_decl *) pi;
|
||
|
||
#ifdef GATHER_STATISTICS
|
||
tree_node_counts[(int)lang_decl] += 1;
|
||
tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
|
||
#endif
|
||
}
|
||
|
||
void
|
||
dump_time_statistics ()
|
||
{
|
||
register tree prev = 0, decl, next;
|
||
int this_time = my_get_run_time ();
|
||
TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
|
||
+= this_time - body_time;
|
||
|
||
fprintf (stderr, "\n******\n");
|
||
print_time ("header files (total)", header_time);
|
||
print_time ("main file (total)", this_time - body_time);
|
||
fprintf (stderr, "ratio = %g : 1\n",
|
||
(double)header_time / (double)(this_time - body_time));
|
||
fprintf (stderr, "\n******\n");
|
||
|
||
for (decl = filename_times; decl; decl = next)
|
||
{
|
||
next = IDENTIFIER_GLOBAL_VALUE (decl);
|
||
IDENTIFIER_GLOBAL_VALUE (decl) = prev;
|
||
prev = decl;
|
||
}
|
||
|
||
for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
|
||
print_time (IDENTIFIER_POINTER (decl),
|
||
TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
|
||
}
|
||
|
||
void
|
||
compiler_error (s, v, v2)
|
||
char *s;
|
||
HOST_WIDE_INT v, v2; /* @@also used as pointer */
|
||
{
|
||
char buf[1024];
|
||
sprintf (buf, s, v, v2);
|
||
error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
|
||
}
|
||
|
||
void
|
||
compiler_error_with_decl (decl, s)
|
||
tree decl;
|
||
char *s;
|
||
{
|
||
char *name;
|
||
count_error (0);
|
||
|
||
report_error_function (0);
|
||
|
||
if (TREE_CODE (decl) == PARM_DECL)
|
||
fprintf (stderr, "%s:%d: ",
|
||
DECL_SOURCE_FILE (DECL_CONTEXT (decl)),
|
||
DECL_SOURCE_LINE (DECL_CONTEXT (decl)));
|
||
else
|
||
fprintf (stderr, "%s:%d: ",
|
||
DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
|
||
|
||
name = lang_printable_name (decl);
|
||
if (name)
|
||
fprintf (stderr, s, name);
|
||
else
|
||
fprintf (stderr, s, "((anonymous))");
|
||
fprintf (stderr, " (compiler error)\n");
|
||
}
|
||
|
||
void
|
||
yyerror (string)
|
||
char *string;
|
||
{
|
||
extern int end_of_file;
|
||
char buf[200];
|
||
|
||
strcpy (buf, string);
|
||
|
||
/* We can't print string and character constants well
|
||
because the token_buffer contains the result of processing escapes. */
|
||
if (end_of_file)
|
||
strcat (buf, input_redirected ()
|
||
? " at end of saved text"
|
||
: " at end of input");
|
||
else if (token_buffer[0] == 0)
|
||
strcat (buf, " at null character");
|
||
else if (token_buffer[0] == '"')
|
||
strcat (buf, " before string constant");
|
||
else if (token_buffer[0] == '\'')
|
||
strcat (buf, " before character constant");
|
||
else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
|
||
sprintf (buf + strlen (buf), " before character 0%o",
|
||
(unsigned char) token_buffer[0]);
|
||
else
|
||
strcat (buf, " before `%s'");
|
||
|
||
error (buf, token_buffer);
|
||
}
|
||
|
||
#ifdef HANDLE_SYSV_PRAGMA
|
||
|
||
/* Handle a #pragma directive. INPUT is the current input stream,
|
||
and C is a character to reread. Processes the entire input line
|
||
and returns a character for the caller to reread: either \n or EOF. */
|
||
|
||
/* This function has to be in this file, in order to get at
|
||
the token types. */
|
||
|
||
handle_sysv_pragma ()
|
||
{
|
||
for (;;)
|
||
{
|
||
switch (yylex ())
|
||
{
|
||
case IDENTIFIER:
|
||
case TYPENAME:
|
||
case STRING:
|
||
case CONSTANT:
|
||
handle_pragma_token ("ignored", yylval.ttype);
|
||
break;
|
||
case '(':
|
||
handle_pragma_token ("(", NULL_TREE);
|
||
break;
|
||
case ')':
|
||
handle_pragma_token (")", NULL_TREE);
|
||
break;
|
||
case ',':
|
||
handle_pragma_token (",", NULL_TREE);
|
||
break;
|
||
case '=':
|
||
handle_pragma_token ("=", NULL_TREE);
|
||
break;
|
||
case LEFT_RIGHT:
|
||
handle_pragma_token ("(", NULL_TREE);
|
||
handle_pragma_token (")", NULL_TREE);
|
||
break;
|
||
case END_OF_LINE:
|
||
handle_pragma_token (NULL_PTR, NULL_TREE);
|
||
return;
|
||
default:
|
||
handle_pragma_token (NULL_PTR, NULL_TREE);
|
||
while (yylex () != END_OF_LINE)
|
||
/* continue */;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
#endif /* HANDLE_SYSV_PRAGMA */
|