3896 lines
100 KiB
Plaintext
3896 lines
100 KiB
Plaintext
/*
|
||
* Changes for branch coverage: Jan-May, 1990,
|
||
* Thomas Hoch, Brian Marick, K. Wolfram Schafer
|
||
* Look for the comment "BRANCH"
|
||
*/
|
||
|
||
|
||
/* YACC parser for C syntax.
|
||
Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
|
||
|
||
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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
|
||
/* To whomever it may concern: I have heard that such a thing was once
|
||
written by AT&T, but I have never seen it. */
|
||
|
||
%expect 8
|
||
|
||
/* These are the 8 conflicts you should get in parse.output;
|
||
the state numbers may vary if minor changes in the grammar are made.
|
||
|
||
State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 92 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 99 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 103 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 119 contains 1 shift/reduce conflict. (See comment at component_decl.)
|
||
State 183 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 193 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
State 199 contains 1 shift/reduce conflict. (Two ways to recover from error.)
|
||
*/
|
||
|
||
%{
|
||
#include "config.h"
|
||
#include "tree.h"
|
||
#include "input.h"
|
||
#include "c-parse.h"
|
||
#include "c-tree.h"
|
||
|
||
#include <stdio.h>
|
||
#include <errno.h>
|
||
#include <string.h>
|
||
#include <sys/file.h>
|
||
|
||
#ifndef errno
|
||
extern int errno;
|
||
#endif
|
||
|
||
/*
|
||
BTOOLGLOBAL DATASTRUCTURES:
|
||
|
||
FILE *finput
|
||
Pointer to the source of char to be processed by the lexical
|
||
analyzer.
|
||
|
||
char *main_input_filename
|
||
Name of the original input file that is being processed.
|
||
|
||
FILE *Mapfile
|
||
Pointer to the map file that is being created by btool.
|
||
|
||
char *Mapfile_name
|
||
Name of the map file that is being created by btool.
|
||
|
||
FILE *Rewritten_output
|
||
Pointer to the rewritten output file.
|
||
|
||
char *Tempname
|
||
Holds the name of the rewritten output file.
|
||
|
||
int Initialized
|
||
Initialized = 1 tells you that btool_init was already called for
|
||
that particular file.
|
||
Initialized = 0 means that btool_init was not called so far.
|
||
|
||
char to_print_char
|
||
Temporary buffer for a char that has be read by the lexical
|
||
analyzer but has not been written to the rewritten output file.
|
||
|
||
int any_to_print
|
||
A flag that will be equal to 1 if a char is in the to_print_char
|
||
variable that has not been written to the rewritten output file.
|
||
|
||
int Switch_level
|
||
Counter for the depth of nested switches. Use as an index for
|
||
Switch_brace_level and Switch_default_seen
|
||
|
||
int Switch_brace_level[100]
|
||
Each element in this array is a counter for the number of braces
|
||
seen of a particular switch_level. It is used in tee_getc in
|
||
conjunction with Switch_default_seen to determine if a particular
|
||
switch statement has a default case.
|
||
|
||
int Switch_default_seen[100]
|
||
Each element in this array is a boolean variable that is equal to 1
|
||
if a default case was seen on a particular switch_level. See also
|
||
Switch_brace_level.
|
||
|
||
int Branch_count
|
||
Holds the number of so far encountered branches. It is initialized
|
||
in btool_init by setting it equal to NUM_BRANCHES which is read
|
||
form the header file.
|
||
|
||
int Name_in_control
|
||
int Inside_macro
|
||
int Function_in_macro
|
||
int User_prevent
|
||
int User_force
|
||
These determine whether a function should be instrumented.
|
||
Name_in_control is true if a function's name was found in the
|
||
control file (or if no functions were specified).
|
||
Inside_macro is true if the code being looked at results from
|
||
a macro expansion (is between the markers that the preprocessor
|
||
adds when -test-macro is not supplied).
|
||
Function_in_macro is set when a function definition was
|
||
found inside a macro.
|
||
User_prevent indicates that the user has used (and not cancelled)
|
||
#btool_prevent.
|
||
User_force indicates that the user has used (and not cancelled)
|
||
#btool_force.
|
||
These variables are used by should_instrument().
|
||
*/
|
||
/* BRANCH - forward declarations. */
|
||
|
||
#define PATH_BUF_LEN 1025
|
||
|
||
extern char *Mapfile_name;
|
||
extern char *Countfile_name;
|
||
extern char *Controlfile_name;
|
||
extern char *Dir_name;
|
||
extern int Test_dir;
|
||
extern FILE *Rewritten_output;
|
||
|
||
int Switch_level = 0; /* Number of nested switches. */
|
||
int Max_switch_level = 1; /* Must be at least 1 because used to
|
||
declare array. */
|
||
int Switch_brace_level[500]; /* Number of braces within switch */
|
||
int Switch_default_seen[500];
|
||
|
||
extern int Btool_instr_quest; /* 1= ? is instrumented, 0=is not */
|
||
int Name_in_control = 0; /* See above for meaning of these. */
|
||
int Inside_macro = 0;
|
||
int Function_in_macro = 0;
|
||
int User_prevent = 0;
|
||
int User_force = 0;
|
||
int Same_number; /* Buffer for ?-branch number */
|
||
|
||
int
|
||
should_instrument()
|
||
{
|
||
return ( ( Name_in_control
|
||
&& (!Inside_macro || Function_in_macro)
|
||
&& !User_prevent)
|
||
|| (User_force && !User_prevent));
|
||
}
|
||
|
||
|
||
/*
|
||
NAME:
|
||
send_output(va_alist)
|
||
|
||
extern FILE *Rewritten_output
|
||
|
||
PURPOSE:
|
||
This routine writes out the rewritten code to the rewritten
|
||
output file by simulating the fprintf function. It is called every
|
||
time the parser wants to add function calls to the code. Only if
|
||
should_instrument() = 1 is code written out.
|
||
|
||
PRECONDITIONS:
|
||
1. The rewirtten outputfile must be open.
|
||
2. It must be possible to write out all data.
|
||
|
||
POSTCONDITIONS:
|
||
The rewirtten output file is updated iff should_instrument().
|
||
|
||
ERRORS:
|
||
1.-2. are not checked (caller's resposibility).
|
||
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
#include <varargs.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
|
||
|
||
/*VARARGS*/
|
||
void
|
||
send_output(va_alist)
|
||
va_dcl
|
||
{
|
||
va_list args;
|
||
char *format;
|
||
|
||
if (should_instrument())
|
||
{
|
||
va_start(args);
|
||
format = va_arg(args, char *);
|
||
(void) vfprintf(Rewritten_output, format, args);
|
||
va_end(args);
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
NAME:
|
||
btool_build_number(Branch_type)
|
||
char *Branch_type;
|
||
|
||
extern FILE *Mapfile
|
||
extern int lineno
|
||
extern int Branch_count
|
||
extern char *input_filename
|
||
|
||
PURPOSE:
|
||
The purpose of this routine is to compute the new branch number and
|
||
to write out the map file information.
|
||
|
||
PRECONDITIONS:
|
||
1. The mapfile is open
|
||
2. It is possible to write all the data to the map file.
|
||
|
||
POSTCONDITIONS:
|
||
The information for a particular branch is written to the map file
|
||
and the branch number is increased by one.
|
||
|
||
ERRORS:
|
||
1.- 2. are not checked (caller's resposibility).
|
||
|
||
*/
|
||
#define BTOOL_DO_WHILE 1
|
||
#define BTOOL_DEFAULT 2
|
||
#define BTOOL_IF 3
|
||
#define BTOOL_QUEST 4
|
||
#define BTOOL_WHILE 5
|
||
#define BTOOL_FOR 6
|
||
#define BTOOL_CASE 7
|
||
#define BTOOL_FUNC 8
|
||
|
||
int
|
||
Btool_build_number(Branch_type, name)
|
||
int Branch_type;
|
||
char *name; /* for function names */
|
||
{
|
||
char *full_filename;
|
||
int number,i;
|
||
static char Branch_str[9][10];
|
||
static int on_line_count[9];
|
||
static int last_lineno = -1;
|
||
extern int lineno;
|
||
extern char *input_filename;
|
||
extern int Branch_count;
|
||
extern FILE *Mapfile;
|
||
extern FILE *Bcountfile;
|
||
|
||
extern char* ctrlfile_name();
|
||
|
||
if (should_instrument())
|
||
{
|
||
if (last_lineno == -1) {
|
||
strcpy(Branch_str[1],"do-while");
|
||
strcpy(Branch_str[2],"default");
|
||
strcpy(Branch_str[3],"if");
|
||
strcpy(Branch_str[4],"?");
|
||
strcpy(Branch_str[5],"while");
|
||
strcpy(Branch_str[6],"for");
|
||
strcpy(Branch_str[7],"case");
|
||
strcpy(Branch_str[8],"func");
|
||
}
|
||
if (lineno != last_lineno)
|
||
{
|
||
last_lineno = lineno;
|
||
for (i=1;i<9;i++)
|
||
on_line_count[i] = 0;
|
||
}
|
||
on_line_count[Branch_type]=on_line_count[Branch_type] +1;
|
||
|
||
full_filename = ctrlfile_name(input_filename);
|
||
/* handle concurrent updates */
|
||
flock(fileno(Mapfile), LOCK_EX);
|
||
rewind(Bcountfile);
|
||
if ((i = fscanf(Bcountfile, "%d", &Branch_count)) != 1) {
|
||
struct stat sb;
|
||
fstat(fileno(Bcountfile), &sb);
|
||
if (sb.st_size != 0)
|
||
fatal("Bcount file corrupt! rv %d\n", i);
|
||
Branch_count = 0;
|
||
}
|
||
|
||
fprintf(Mapfile, "%d %s %d %s %d %s\n", Branch_count, full_filename, lineno, Branch_str[Branch_type], on_line_count[Branch_type], name);
|
||
|
||
number = Branch_count;
|
||
|
||
Branch_count++;
|
||
rewind(Bcountfile);
|
||
fprintf(Bcountfile, "%d\n", Branch_count);
|
||
flock(fileno(Mapfile), LOCK_UN);
|
||
}
|
||
else
|
||
{
|
||
number =0;
|
||
}
|
||
return(number);
|
||
}
|
||
|
||
/* END BRANCH */
|
||
|
||
void yyerror ();
|
||
|
||
/* Cause the `yydebug' variable to be defined. */
|
||
#define YYDEBUG 1
|
||
%}
|
||
|
||
%start program
|
||
|
||
%union {long itype; tree ttype; enum tree_code code; }
|
||
|
||
/* All identifiers that are not reserved words
|
||
and are not declared typedefs in the current block */
|
||
%token IDENTIFIER
|
||
|
||
/* All identifiers that are declared typedefs in the current block.
|
||
In some contexts, they are treated just like IDENTIFIER,
|
||
but they can also serve as typespecs in declarations. */
|
||
%token TYPENAME
|
||
|
||
/* Reserved words that specify storage class.
|
||
yylval contains an IDENTIFIER_NODE which indicates which one. */
|
||
%token SCSPEC
|
||
|
||
/* Reserved words that specify type.
|
||
yylval contains an IDENTIFIER_NODE which indicates which one. */
|
||
%token TYPESPEC
|
||
|
||
/* Reserved words that qualify type: "const" or "volatile".
|
||
yylval contains an IDENTIFIER_NODE which indicates which one. */
|
||
%token TYPE_QUAL
|
||
|
||
/* Character or numeric constants.
|
||
yylval is the node for the constant. */
|
||
%token CONSTANT
|
||
|
||
/* String constants in raw form.
|
||
yylval is a STRING_CST node. */
|
||
%token STRING
|
||
|
||
/* "...", used for functions with variable arglists. */
|
||
%token ELLIPSIS
|
||
|
||
/* the reserved words */
|
||
%token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
|
||
%token BREAK CONTINUE RETURN GOTO ASM TYPEOF ALIGNOF
|
||
%token ATTRIBUTE
|
||
|
||
/* Add precedence rules to solve dangling else s/r conflict */
|
||
%nonassoc IF
|
||
%nonassoc ELSE
|
||
|
||
/* Define the operator tokens and their precedences.
|
||
The value is an integer because, if used, it is the tree code
|
||
to use in the expression made from the operator. */
|
||
|
||
%right <code> ASSIGN '='
|
||
%right <code> '?' ':'
|
||
%left <code> OROR
|
||
%left <code> ANDAND
|
||
%left <code> '|'
|
||
%left <code> '^'
|
||
%left <code> '&'
|
||
%left <code> EQCOMPARE
|
||
%left <code> ARITHCOMPARE
|
||
%left <code> LSHIFT RSHIFT
|
||
%left <code> '+' '-'
|
||
%left <code> '*' '/' '%'
|
||
%right <code> UNARY PLUSPLUS MINUSMINUS
|
||
%left HYPERUNARY
|
||
%left <code> POINTSAT '.' '(' '['
|
||
|
||
%type <code> unop
|
||
|
||
%type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
|
||
%type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
|
||
%type <ttype> typed_declspecs reserved_declspecs
|
||
%type <ttype> typed_typespecs reserved_typespecquals
|
||
%type <ttype> declmods typespec typespecqual_reserved
|
||
%type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
|
||
%type <ttype> initdecls notype_initdecls initdcl notype_initdcl
|
||
%type <ttype> init initlist maybeasm
|
||
%type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
|
||
%type <ttype> maybe_attribute attribute_list attrib
|
||
|
||
%type <ttype> compstmt
|
||
|
||
%type <ttype> declarator
|
||
%type <ttype> notype_declarator after_type_declarator
|
||
%type <ttype> parm_declarator
|
||
|
||
%type <ttype> structsp component_decl_list component_decl components component_declarator
|
||
%type <ttype> enumlist enumerator
|
||
%type <ttype> typename absdcl absdcl1 type_quals
|
||
%type <ttype> xexpr parms parm identifiers
|
||
|
||
%type <ttype> parmlist parmlist_1 parmlist_2
|
||
%type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
|
||
|
||
%type <itype> setspecs
|
||
|
||
%{
|
||
/* 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. */
|
||
static tree lastiddecl;
|
||
|
||
static tree make_pointer_declarator ();
|
||
static tree combine_strings ();
|
||
static void reinit_parse_for_function ();
|
||
|
||
/* List of types and structure classes of the current declaration. */
|
||
tree current_declspecs;
|
||
|
||
/* Stack of saved values of current_declspecs. */
|
||
tree declspec_stack;
|
||
|
||
int undeclared_variable_notice; /* 1 if we explained undeclared var errors. */
|
||
|
||
static int yylex ();
|
||
%}
|
||
|
||
%%
|
||
program: /* empty */
|
||
| extdefs
|
||
;
|
||
|
||
/* the reason for the strange actions in this rule
|
||
is so that notype_initdecls when reached via datadef
|
||
can find a valid list of type and sc specs in $0. */
|
||
|
||
extdefs:
|
||
{$<ttype>$ = NULL_TREE; } extdef
|
||
| extdefs {$<ttype>$ = NULL_TREE; } extdef
|
||
;
|
||
|
||
extdef:
|
||
fndef
|
||
| datadef
|
||
| ASM '(' string ')' ';'
|
||
{ if (pedantic)
|
||
warning ("ANSI C forbids use of `asm' keyword");
|
||
if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
|
||
assemble_asm ($3); }
|
||
;
|
||
|
||
datadef:
|
||
setspecs notype_initdecls ';'
|
||
{ if (pedantic)
|
||
error ("ANSI C forbids data definition lacking type or storage class");
|
||
else if (!flag_traditional)
|
||
warning ("data definition lacks type or storage class"); }
|
||
| declmods setspecs notype_initdecls ';'
|
||
{}
|
||
| typed_declspecs setspecs initdecls ';'
|
||
{}
|
||
| declmods ';'
|
||
{ error ("empty declaration"); }
|
||
| typed_declspecs ';'
|
||
{ shadow_tag ($1); }
|
||
| error ';'
|
||
| error '}'
|
||
| ';'
|
||
{ if (pedantic)
|
||
warning ("ANSI C does not allow extra `;' outside of a function"); }
|
||
;
|
||
|
||
fndef:
|
||
typed_declspecs setspecs declarator
|
||
{ if (! start_function ($1, $3))
|
||
YYERROR;
|
||
#ifdef sgi
|
||
start_func();
|
||
#endif
|
||
reinit_parse_for_function (); }
|
||
xdecls
|
||
{ store_parm_decls (); }
|
||
compstmt_or_error
|
||
{ finish_function (lineno); }
|
||
| typed_declspecs setspecs declarator error
|
||
{ }
|
||
| declmods setspecs notype_declarator
|
||
{ if (! start_function ($1, $3))
|
||
YYERROR;
|
||
#ifdef sgi
|
||
start_func();
|
||
#endif
|
||
reinit_parse_for_function (); }
|
||
xdecls
|
||
{ store_parm_decls (); }
|
||
compstmt_or_error
|
||
{ finish_function (lineno); }
|
||
| declmods setspecs notype_declarator error
|
||
{ }
|
||
| setspecs notype_declarator
|
||
{ if (! start_function (0, $2))
|
||
YYERROR;
|
||
#ifdef sgi
|
||
start_func();
|
||
#endif
|
||
reinit_parse_for_function (); }
|
||
xdecls
|
||
{ store_parm_decls (); }
|
||
compstmt_or_error
|
||
{ finish_function (lineno); }
|
||
| setspecs notype_declarator error
|
||
{ }
|
||
;
|
||
|
||
identifier:
|
||
IDENTIFIER
|
||
| TYPENAME
|
||
;
|
||
|
||
unop: '&'
|
||
{ $$ = ADDR_EXPR; }
|
||
| '-'
|
||
{ $$ = NEGATE_EXPR; }
|
||
| '+'
|
||
{ $$ = CONVERT_EXPR; }
|
||
| PLUSPLUS
|
||
{ $$ = PREINCREMENT_EXPR; }
|
||
| MINUSMINUS
|
||
{ $$ = PREDECREMENT_EXPR; }
|
||
| '~'
|
||
{ $$ = BIT_NOT_EXPR; }
|
||
| '!'
|
||
{ $$ = TRUTH_NOT_EXPR; }
|
||
;
|
||
|
||
expr: nonnull_exprlist
|
||
{ $$ = build_compound_expr ($1); }
|
||
;
|
||
|
||
exprlist:
|
||
/* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| nonnull_exprlist
|
||
;
|
||
|
||
nonnull_exprlist:
|
||
expr_no_commas
|
||
{ $$ = build_tree_list (NULL_TREE, $1); }
|
||
| nonnull_exprlist ',' expr_no_commas
|
||
{ chainon ($1, build_tree_list (NULL_TREE, $3)); }
|
||
;
|
||
|
||
unary_expr:
|
||
primary
|
||
| '*' cast_expr %prec UNARY
|
||
{ $$ = build_indirect_ref ($2, "unary *"); }
|
||
| unop cast_expr %prec UNARY
|
||
{ $$ = build_unary_op ($1, $2, 0); }
|
||
| SIZEOF unary_expr %prec UNARY
|
||
{ if (TREE_CODE ($2) == COMPONENT_REF
|
||
&& TREE_PACKED (TREE_OPERAND ($2, 1)))
|
||
error ("`sizeof' applied to a bit-field");
|
||
$$ = c_sizeof (TREE_TYPE ($2)); }
|
||
| SIZEOF '(' typename ')' %prec HYPERUNARY
|
||
{ $$ = c_sizeof (groktypename ($3)); }
|
||
| ALIGNOF unary_expr %prec UNARY
|
||
{ if (TREE_CODE ($2) == COMPONENT_REF
|
||
&& TREE_PACKED (TREE_OPERAND ($2, 1)))
|
||
error ("`__alignof' applied to a bit-field");
|
||
if (TREE_CODE ($2) == INDIRECT_REF)
|
||
{
|
||
tree t = TREE_OPERAND ($2, 0);
|
||
tree best = t;
|
||
int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
|
||
while (TREE_CODE (t) == NOP_EXPR
|
||
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
|
||
{
|
||
int thisalign;
|
||
t = TREE_OPERAND (t, 0);
|
||
thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
|
||
if (thisalign > bestalign)
|
||
best = t, bestalign = thisalign;
|
||
}
|
||
$$ = c_alignof (TREE_TYPE (TREE_TYPE (best)));
|
||
}
|
||
else
|
||
$$ = c_alignof (TREE_TYPE ($2)); }
|
||
| ALIGNOF '(' typename ')' %prec HYPERUNARY
|
||
{ $$ = c_alignof (groktypename ($3)); }
|
||
;
|
||
|
||
cast_expr:
|
||
unary_expr
|
||
| '(' typename ')' cast_expr %prec UNARY
|
||
{ tree type = groktypename ($2);
|
||
$$ = build_c_cast (type, $4); }
|
||
| '(' typename ')' '{' initlist maybecomma '}' %prec UNARY
|
||
{ tree type = groktypename ($2);
|
||
if (pedantic)
|
||
warning ("ANSI C forbids constructor expressions");
|
||
$$ = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5)), 0);
|
||
if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
|
||
{
|
||
int failure = complete_array_type (type, $$, 1);
|
||
if (failure)
|
||
abort ();
|
||
}
|
||
}
|
||
;
|
||
|
||
expr_no_commas:
|
||
cast_expr
|
||
| expr_no_commas '+' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '-' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '*' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '/' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '%' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas LSHIFT expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas RSHIFT expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas ARITHCOMPARE expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas EQCOMPARE expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '&' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '|' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas '^' expr_no_commas
|
||
{ $$ = build_binary_op ($2, $1, $3); }
|
||
| expr_no_commas ANDAND expr_no_commas
|
||
{ $$ = build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); }
|
||
| expr_no_commas OROR expr_no_commas
|
||
{ $$ = build_binary_op (TRUTH_ORIF_EXPR, $1, $3); }
|
||
/* BRANCH */
|
||
| expr_no_commas
|
||
'?'
|
||
{
|
||
|
||
if (Btool_instr_quest) {
|
||
btool_flush_char(1);
|
||
Same_number = Btool_build_number(BTOOL_QUEST, NULL);
|
||
send_output("(btool_branch(%d,1),",Same_number);
|
||
}
|
||
}
|
||
xexpr
|
||
{
|
||
if (Btool_instr_quest) {
|
||
send_output(")");
|
||
}
|
||
}
|
||
':'
|
||
{
|
||
if (Btool_instr_quest) {
|
||
btool_flush_char(1);
|
||
send_output("(btool_branch(%d,0),",Same_number);
|
||
}
|
||
}
|
||
expr_no_commas
|
||
{
|
||
if (Btool_instr_quest) {
|
||
send_output(")");
|
||
}
|
||
$$ = build_conditional_expr ($1, $4, $8); }
|
||
| expr_no_commas '=' expr_no_commas
|
||
{ $$ = build_modify_expr ($1, NOP_EXPR, $3); }
|
||
| expr_no_commas ASSIGN expr_no_commas
|
||
{ $$ = build_modify_expr ($1, $2, $3); }
|
||
;
|
||
primary:
|
||
IDENTIFIER
|
||
{ $$ = lastiddecl;
|
||
if (!$$ || $$ == error_mark_node)
|
||
{
|
||
if (yychar == YYEMPTY)
|
||
yychar = YYLEX;
|
||
if (yychar == '(')
|
||
{
|
||
$$ = implicitly_declare ($1);
|
||
assemble_external ($$);
|
||
TREE_USED ($$) = 1;
|
||
}
|
||
else if (current_function_decl == 0)
|
||
{
|
||
error ("`%s' undeclared, outside of functions",
|
||
IDENTIFIER_POINTER ($1));
|
||
$$ = error_mark_node;
|
||
}
|
||
else
|
||
{
|
||
if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node
|
||
|| IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl)
|
||
{
|
||
error ("`%s' undeclared (first use this function)",
|
||
IDENTIFIER_POINTER ($1));
|
||
|
||
if (! undeclared_variable_notice)
|
||
{
|
||
error ("(Each undeclared identifier is reported only once");
|
||
error ("for each function it appears in.)");
|
||
undeclared_variable_notice = 1;
|
||
}
|
||
}
|
||
$$ = error_mark_node;
|
||
/* Prevent repeated error messages. */
|
||
IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node;
|
||
IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl;
|
||
}
|
||
}
|
||
else if (! TREE_USED ($$))
|
||
{
|
||
if (TREE_EXTERNAL ($$))
|
||
assemble_external ($$);
|
||
TREE_USED ($$) = 1;
|
||
}
|
||
if (TREE_CODE ($$) == CONST_DECL)
|
||
$$ = DECL_INITIAL ($$);
|
||
}
|
||
| CONSTANT
|
||
| string
|
||
{ $$ = combine_strings ($1); }
|
||
| '(' expr ')'
|
||
{ $$ = $2; }
|
||
| '(' error ')'
|
||
{ $$ = error_mark_node; }
|
||
| '('
|
||
{ if (current_function_decl == 0)
|
||
{
|
||
error ("braced-group within expression allowed only inside a function");
|
||
YYERROR;
|
||
}
|
||
keep_next_level ();
|
||
$<ttype>$ = expand_start_stmt_expr (); }
|
||
compstmt ')'
|
||
{ tree rtl_exp;
|
||
if (pedantic)
|
||
warning ("ANSI C forbids braced-groups within expressions");
|
||
rtl_exp = expand_end_stmt_expr ($<ttype>2);
|
||
$$ = $3;
|
||
TREE_USED ($$) = 0;
|
||
/* Since the statements have side effects,
|
||
consider this volatile. */
|
||
TREE_VOLATILE ($$) = 1;
|
||
TREE_TYPE ($$) = TREE_TYPE (rtl_exp);
|
||
STMT_BODY ($$) = rtl_exp; }
|
||
| primary '(' exprlist ')' %prec '.'
|
||
{ $$ = build_function_call ($1, $3); }
|
||
| primary '[' expr ']' %prec '.'
|
||
{ $$ = build_array_ref ($1, $3); }
|
||
| primary '.' identifier
|
||
{ $$ = build_component_ref ($1, $3); }
|
||
| primary POINTSAT identifier
|
||
{ $$ = build_component_ref (build_indirect_ref ($1, "->"), $3); }
|
||
| primary PLUSPLUS
|
||
{ $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
|
||
| primary MINUSMINUS
|
||
{ $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
|
||
;
|
||
|
||
/* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
|
||
string:
|
||
STRING
|
||
| string STRING
|
||
{ $$ = chainon ($1, $2); }
|
||
;
|
||
|
||
xdecls:
|
||
/* empty */
|
||
| decls
|
||
;
|
||
|
||
decls:
|
||
decl
|
||
| errstmt
|
||
| decls decl
|
||
| decl errstmt
|
||
;
|
||
|
||
/* records the type and storage class specs to use for processing
|
||
the declarators that follow.
|
||
Maintains a stack of outer-level values of current_declspecs,
|
||
for the sake of parm declarations nested in function declarators. */
|
||
setspecs: /* empty */
|
||
{ $$ = suspend_momentary ();
|
||
declspec_stack = tree_cons (0, current_declspecs,
|
||
declspec_stack);
|
||
current_declspecs = $<ttype>0; }
|
||
;
|
||
|
||
decl:
|
||
typed_declspecs setspecs initdecls ';'
|
||
{ current_declspecs = TREE_VALUE (declspec_stack);
|
||
declspec_stack = TREE_CHAIN (declspec_stack);
|
||
resume_momentary ($2); }
|
||
| declmods setspecs notype_initdecls ';'
|
||
{ current_declspecs = TREE_VALUE (declspec_stack);
|
||
declspec_stack = TREE_CHAIN (declspec_stack);
|
||
resume_momentary ($2); }
|
||
| typed_declspecs ';'
|
||
{ shadow_tag ($1); }
|
||
| declmods ';'
|
||
{ warning ("empty declaration"); }
|
||
;
|
||
|
||
/* Declspecs which contain at least one type specifier or typedef name.
|
||
(Just `const' or `volatile' is not enough.)
|
||
A typedef'd name following these is taken as a name to be declared. */
|
||
|
||
typed_declspecs:
|
||
typespec reserved_declspecs
|
||
{ $$ = tree_cons (NULL_TREE, $1, $2); }
|
||
| declmods typespec reserved_declspecs
|
||
{ $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
|
||
;
|
||
|
||
reserved_declspecs: /* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| reserved_declspecs typespecqual_reserved
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
| reserved_declspecs SCSPEC
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
;
|
||
|
||
/* List of just storage classes and type modifiers.
|
||
A declaration can start with just this, but then it cannot be used
|
||
to redeclare a typedef-name. */
|
||
|
||
declmods:
|
||
TYPE_QUAL
|
||
{ $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
|
||
| SCSPEC
|
||
{ $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
|
||
| declmods TYPE_QUAL
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
| declmods SCSPEC
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
;
|
||
|
||
|
||
/* Used instead of declspecs where storage classes are not allowed
|
||
(that is, for typenames and structure components).
|
||
Don't accept a typedef-name if anything but a modifier precedes it. */
|
||
|
||
typed_typespecs:
|
||
typespec reserved_typespecquals
|
||
{ $$ = tree_cons (NULL_TREE, $1, $2); }
|
||
| nonempty_type_quals typespec reserved_typespecquals
|
||
{ $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
|
||
;
|
||
|
||
reserved_typespecquals: /* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| reserved_typespecquals typespecqual_reserved
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
;
|
||
|
||
/* A typespec (but not a type qualifier).
|
||
Once we have seen one of these in a declaration,
|
||
if a typedef name appears then it is being redeclared. */
|
||
|
||
typespec: TYPESPEC
|
||
| structsp
|
||
| TYPENAME
|
||
| TYPEOF '(' expr ')'
|
||
{ $$ = TREE_TYPE ($3);
|
||
if (pedantic)
|
||
warning ("ANSI C forbids `typeof'"); }
|
||
| TYPEOF '(' typename ')'
|
||
{ $$ = groktypename ($3);
|
||
if (pedantic)
|
||
warning ("ANSI C forbids `typeof'"); }
|
||
;
|
||
|
||
/* A typespec that is a reserved word, or a type qualifier. */
|
||
|
||
typespecqual_reserved: TYPESPEC
|
||
| TYPE_QUAL
|
||
| structsp
|
||
;
|
||
|
||
initdecls:
|
||
initdcl
|
||
| initdecls ',' initdcl
|
||
;
|
||
|
||
notype_initdecls:
|
||
notype_initdcl
|
||
| notype_initdecls ',' initdcl
|
||
;
|
||
|
||
maybeasm:
|
||
/* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| ASM '(' string ')'
|
||
{ if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
|
||
$$ = $3;
|
||
if (pedantic)
|
||
warning ("ANSI C forbids use of `asm' keyword");
|
||
}
|
||
;
|
||
|
||
initdcl:
|
||
declarator maybeasm maybe_attribute '='
|
||
{ $<ttype>$ = start_decl ($1, current_declspecs, 1); }
|
||
init
|
||
/* Note how the declaration of the variable is in effect while its init is parsed! */
|
||
{ finish_decl ($<ttype>5, $6, $2); }
|
||
| declarator maybeasm maybe_attribute
|
||
{ tree d = start_decl ($1, current_declspecs, 0);
|
||
finish_decl (d, NULL_TREE, $2); }
|
||
;
|
||
|
||
notype_initdcl:
|
||
notype_declarator maybeasm maybe_attribute '='
|
||
{ $<ttype>$ = start_decl ($1, current_declspecs, 1); }
|
||
init
|
||
/* Note how the declaration of the variable is in effect while its init is parsed! */
|
||
{ finish_decl ($<ttype>5, $6, $2); }
|
||
| notype_declarator maybeasm maybe_attribute
|
||
{ tree d = start_decl ($1, current_declspecs, 0);
|
||
finish_decl (d, NULL_TREE, $2); }
|
||
;
|
||
/* the * rules are dummies to accept the Apollo extended syntax
|
||
so that the header files compile. */
|
||
maybe_attribute:
|
||
/* empty */
|
||
| ATTRIBUTE '(' '(' attribute_list ')' ')'
|
||
{ $$ = $4; }
|
||
;
|
||
|
||
attribute_list
|
||
: attrib
|
||
| attribute_list ',' attrib
|
||
;
|
||
|
||
attrib
|
||
: IDENTIFIER
|
||
{ warning ("`%s' attribute directive ignored",
|
||
IDENTIFIER_POINTER ($1));
|
||
$$ = $1; }
|
||
| IDENTIFIER '(' CONSTANT ')'
|
||
{ /* if not "aligned(1)", then issue warning */
|
||
if (strcmp (IDENTIFIER_POINTER ($1), "aligned") != 0
|
||
|| TREE_CODE ($3) != INTEGER_CST
|
||
|| TREE_INT_CST_LOW ($3) != 1)
|
||
warning ("`%s' attribute directive ignored",
|
||
IDENTIFIER_POINTER ($1));
|
||
$$ = $1; }
|
||
| IDENTIFIER '(' identifiers ')'
|
||
{ warning ("`%s' attribute directive ignored",
|
||
IDENTIFIER_POINTER ($1));
|
||
$$ = $1; }
|
||
;
|
||
|
||
init:
|
||
expr_no_commas
|
||
| '{' '}'
|
||
{ $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
|
||
if (pedantic)
|
||
warning ("ANSI C forbids empty initializer braces"); }
|
||
| '{' initlist '}'
|
||
{ $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
|
||
| '{' initlist ',' '}'
|
||
{ $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
|
||
| error
|
||
{ $$ = NULL_TREE; }
|
||
;
|
||
|
||
/* This chain is built in reverse order,
|
||
and put in forward order where initlist is used. */
|
||
initlist:
|
||
init
|
||
{ $$ = build_tree_list (NULL_TREE, $1); }
|
||
| initlist ',' init
|
||
{ $$ = tree_cons (NULL_TREE, $3, $1); }
|
||
;
|
||
|
||
/* Any kind of declarator (thus, all declarators allowed
|
||
after an explicit typespec). */
|
||
|
||
declarator:
|
||
after_type_declarator
|
||
| notype_declarator
|
||
;
|
||
|
||
/* A declarator that is allowed only after an explicit typespec. */
|
||
|
||
after_type_declarator:
|
||
'(' after_type_declarator ')'
|
||
{ $$ = $2; }
|
||
| after_type_declarator '(' parmlist_or_identifiers %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
|
||
/* | after_type_declarator '(' error ')' %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
|
||
poplevel (0, 0, 0); } */
|
||
| after_type_declarator '[' expr ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, $3); }
|
||
| after_type_declarator '[' ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
|
||
| '*' type_quals after_type_declarator %prec UNARY
|
||
{ $$ = make_pointer_declarator ($2, $3); }
|
||
| TYPENAME
|
||
;
|
||
|
||
/* Kinds of declarator that can appear in a parameter list
|
||
in addition to notype_declarator. This is like after_type_declarator
|
||
but does not allow a typedef name in parentheses as an identifier
|
||
(because it would conflict with a function with that typedef as arg). */
|
||
|
||
parm_declarator:
|
||
parm_declarator '(' parmlist_or_identifiers %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
|
||
/* | parm_declarator '(' error ')' %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
|
||
poplevel (0, 0, 0); } */
|
||
| parm_declarator '[' expr ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, $3); }
|
||
| parm_declarator '[' ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
|
||
| '*' type_quals parm_declarator %prec UNARY
|
||
{ $$ = make_pointer_declarator ($2, $3); }
|
||
| TYPENAME
|
||
;
|
||
|
||
/* A declarator allowed whether or not there has been
|
||
an explicit typespec. These cannot redeclare a typedef-name. */
|
||
|
||
notype_declarator:
|
||
notype_declarator '(' parmlist_or_identifiers %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
|
||
/* | notype_declarator '(' error ')' %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
|
||
poplevel (0, 0, 0); } */
|
||
| '(' notype_declarator ')'
|
||
{ $$ = $2; }
|
||
| '*' type_quals notype_declarator %prec UNARY
|
||
{ $$ = make_pointer_declarator ($2, $3); }
|
||
| notype_declarator '[' expr ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, $3); }
|
||
| notype_declarator '[' ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
|
||
| IDENTIFIER
|
||
;
|
||
|
||
structsp:
|
||
STRUCT identifier '{'
|
||
{ $$ = start_struct (RECORD_TYPE, $2);
|
||
/* Start scope of tag before parsing components. */
|
||
}
|
||
component_decl_list '}'
|
||
{ $$ = finish_struct ($<ttype>4, $5);
|
||
/* Really define the structure. */
|
||
}
|
||
| STRUCT '{' component_decl_list '}'
|
||
{ $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
|
||
$3); }
|
||
| STRUCT identifier
|
||
{ $$ = xref_tag (RECORD_TYPE, $2); }
|
||
| UNION identifier '{'
|
||
{ $$ = start_struct (UNION_TYPE, $2); }
|
||
component_decl_list '}'
|
||
{ $$ = finish_struct ($<ttype>4, $5); }
|
||
| UNION '{' component_decl_list '}'
|
||
{ $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
|
||
$3); }
|
||
| UNION identifier
|
||
{ $$ = xref_tag (UNION_TYPE, $2); }
|
||
| ENUM identifier '{'
|
||
{ $<itype>3 = suspend_momentary ();
|
||
$$ = start_enum ($2); }
|
||
enumlist maybecomma_warn '}'
|
||
{ $$ = finish_enum ($<ttype>4, nreverse ($5));
|
||
resume_momentary ($<itype>3); }
|
||
| ENUM '{'
|
||
{ $<itype>2 = suspend_momentary ();
|
||
$$ = start_enum (NULL_TREE); }
|
||
enumlist maybecomma_warn '}'
|
||
{ $$ = finish_enum ($<ttype>3, nreverse ($4));
|
||
resume_momentary ($<itype>2); }
|
||
| ENUM identifier
|
||
{ $$ = xref_tag (ENUMERAL_TYPE, $2); }
|
||
;
|
||
|
||
maybecomma:
|
||
/* empty */
|
||
| ','
|
||
;
|
||
|
||
maybecomma_warn:
|
||
/* empty */
|
||
| ','
|
||
{ if (pedantic) warning ("comma at end of enumerator list"); }
|
||
;
|
||
|
||
component_decl_list: /* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| component_decl_list component_decl ';'
|
||
{ $$ = chainon ($1, $2); }
|
||
| component_decl_list ';'
|
||
{ if (pedantic)
|
||
warning ("extra semicolon in struct or union specified"); }
|
||
;
|
||
|
||
/* There is a shift-reduce conflict here, because `components' may
|
||
start with a `typename'. It happens that shifting (the default resolution)
|
||
does the right thing, because it treats the `typename' as part of
|
||
a `typed_typespecs'.
|
||
|
||
It is possible that this same technique would allow the distinction
|
||
between `notype_initdecls' and `initdecls' to be eliminated.
|
||
But I am being cautious and not trying it. */
|
||
|
||
component_decl:
|
||
typed_typespecs setspecs components
|
||
{ $$ = $3;
|
||
current_declspecs = TREE_VALUE (declspec_stack);
|
||
declspec_stack = TREE_CHAIN (declspec_stack);
|
||
resume_momentary ($2); }
|
||
| nonempty_type_quals setspecs components
|
||
{ $$ = $3;
|
||
current_declspecs = TREE_VALUE (declspec_stack);
|
||
declspec_stack = TREE_CHAIN (declspec_stack);
|
||
resume_momentary ($2); }
|
||
| error
|
||
{ $$ = NULL_TREE; }
|
||
;
|
||
|
||
components:
|
||
/* empty */
|
||
{ if (pedantic)
|
||
warning ("ANSI C forbids member declarations with no members");
|
||
$$ = NULL_TREE; }
|
||
| component_declarator
|
||
| components ',' component_declarator
|
||
{ $$ = chainon ($1, $3); }
|
||
;
|
||
|
||
component_declarator:
|
||
declarator maybe_attribute
|
||
{ $$ = grokfield (input_filename, lineno, $1, current_declspecs, NULL_TREE); }
|
||
| declarator ':' expr_no_commas maybe_attribute
|
||
{ $$ = grokfield (input_filename, lineno, $1, current_declspecs, $3); }
|
||
| ':' expr_no_commas
|
||
{ $$ = grokfield (input_filename, lineno, NULL_TREE, current_declspecs, $2); }
|
||
;
|
||
|
||
/* We chain the enumerators in reverse order.
|
||
They are put in forward order where enumlist is used.
|
||
(The order used to be significant, but no longer is so.
|
||
However, we still maintain the order, just to be clean.) */
|
||
|
||
enumlist:
|
||
enumerator
|
||
| enumlist ',' enumerator
|
||
{ $$ = chainon ($3, $1); }
|
||
;
|
||
|
||
|
||
enumerator:
|
||
identifier
|
||
{ $$ = build_enumerator ($1, NULL_TREE); }
|
||
| identifier '=' expr_no_commas
|
||
{ $$ = build_enumerator ($1, $3); }
|
||
;
|
||
|
||
typename:
|
||
typed_typespecs absdcl
|
||
{ $$ = build_tree_list ($1, $2); }
|
||
| nonempty_type_quals absdcl
|
||
{ $$ = build_tree_list ($1, $2); }
|
||
;
|
||
|
||
absdcl: /* an absolute declarator */
|
||
/* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| absdcl1
|
||
;
|
||
|
||
nonempty_type_quals:
|
||
TYPE_QUAL
|
||
{ $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
|
||
| nonempty_type_quals TYPE_QUAL
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
;
|
||
|
||
type_quals:
|
||
/* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| type_quals TYPE_QUAL
|
||
{ $$ = tree_cons (NULL_TREE, $2, $1); }
|
||
;
|
||
|
||
absdcl1: /* a nonempty absolute declarator */
|
||
'(' absdcl1 ')'
|
||
{ $$ = $2; }
|
||
/* `(typedef)1' is `int'. */
|
||
| '*' type_quals absdcl1 %prec UNARY
|
||
{ $$ = make_pointer_declarator ($2, $3); }
|
||
| '*' type_quals %prec UNARY
|
||
{ $$ = make_pointer_declarator ($2, NULL_TREE); }
|
||
| absdcl1 '(' parmlist %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
|
||
| absdcl1 '[' expr ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, $3); }
|
||
| absdcl1 '[' ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
|
||
| '(' parmlist %prec '.'
|
||
{ $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
|
||
| '[' expr ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
|
||
| '[' ']' %prec '.'
|
||
{ $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
|
||
;
|
||
|
||
/* at least one statement, the first of which parses without error. */
|
||
/* stmts is used only after decls, so an invalid first statement
|
||
is actually regarded as an invalid decl and part of the decls. */
|
||
|
||
stmts:
|
||
stmt
|
||
| stmts stmt
|
||
| stmts errstmt
|
||
;
|
||
|
||
xstmts:
|
||
/* empty */
|
||
| stmts
|
||
;
|
||
|
||
errstmt: error ';'
|
||
;
|
||
|
||
pushlevel: /* empty */
|
||
{ pushlevel (0);
|
||
clear_last_expr ();
|
||
push_momentary ();
|
||
expand_start_bindings (0); }
|
||
;
|
||
|
||
/* This is the body of a function definition.
|
||
It causes syntax errors to ignore to the next openbrace. */
|
||
compstmt_or_error:
|
||
compstmt
|
||
{}
|
||
| error compstmt
|
||
;
|
||
|
||
/* ifdef sgi */
|
||
compstmt: '{' '}'
|
||
{
|
||
end_func();
|
||
$$ = 0; }
|
||
| '{' pushlevel decls
|
||
{ end_func(); }
|
||
xstmts '}'
|
||
{ expand_end_bindings (getdecls (), 1, 0);
|
||
$$ = poplevel (1, 1, 0);
|
||
pop_momentary (); }
|
||
| '{' pushlevel
|
||
{ end_func(); }
|
||
error '}'
|
||
{ expand_end_bindings (getdecls (), 0, 0);
|
||
$$ = poplevel (0, 0, 0);
|
||
pop_momentary (); }
|
||
| '{' pushlevel
|
||
{ end_func(); }
|
||
stmts '}'
|
||
{ expand_end_bindings (getdecls (), 0, 0);
|
||
$$ = poplevel (0, 0, 0);
|
||
pop_momentary (); }
|
||
;
|
||
/* ifdef OLD
|
||
compstmt: '{' '}'
|
||
{ $$ = 0; }
|
||
| '{' pushlevel decls xstmts '}'
|
||
{ expand_end_bindings (getdecls (), 1, 0);
|
||
$$ = poplevel (1, 1, 0);
|
||
pop_momentary (); }
|
||
| '{' pushlevel error '}'
|
||
{ expand_end_bindings (getdecls (), 0, 0);
|
||
$$ = poplevel (0, 0, 0);
|
||
pop_momentary (); }
|
||
| '{' pushlevel stmts '}'
|
||
{ expand_end_bindings (getdecls (), 0, 0);
|
||
$$ = poplevel (0, 0, 0);
|
||
pop_momentary (); }
|
||
;
|
||
*/
|
||
|
||
simple_if:
|
||
/* BRANCH */
|
||
IF
|
||
{
|
||
send_output("(btool_branch(%d,",Btool_build_number(BTOOL_IF, NULL));
|
||
}
|
||
|
||
'(' expr ')'
|
||
{ emit_line_note (input_filename, lineno);
|
||
expand_start_cond (truthvalue_conversion ($4), 0);
|
||
btool_flush_char(1); /* Flush paren */
|
||
send_output("!=0))");
|
||
}
|
||
stmt
|
||
;
|
||
|
||
stmt:
|
||
compstmt {}
|
||
| expr ';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
/* Do default conversion if safe and possibly important,
|
||
in case within ({...}). */
|
||
if ((TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE
|
||
&& lvalue_p ($1))
|
||
|| TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE)
|
||
$1 = default_conversion ($1);
|
||
expand_expr_stmt ($1);
|
||
clear_momentary (); }
|
||
| simple_if ELSE
|
||
{ expand_start_else (); }
|
||
stmt
|
||
{ expand_end_else (); }
|
||
| simple_if %prec IF
|
||
{ expand_end_cond (); }
|
||
/* BRANCH */
|
||
| WHILE
|
||
{ emit_nop ();
|
||
emit_line_note (input_filename, lineno);
|
||
expand_start_loop (1);
|
||
send_output("(btool_branch(%d,",Btool_build_number(BTOOL_WHILE, NULL));
|
||
}
|
||
'(' expr ')'
|
||
{ emit_line_note (input_filename, lineno);
|
||
expand_exit_loop_if_false (truthvalue_conversion ($4));
|
||
btool_flush_char(1); /* Flush paren */
|
||
send_output("!=0))");
|
||
}
|
||
stmt
|
||
{ expand_end_loop (); }
|
||
/* BRANCH */
|
||
| DO
|
||
{ emit_nop ();
|
||
emit_line_note (input_filename, lineno);
|
||
expand_start_loop_continue_elsewhere (1); }
|
||
stmt WHILE
|
||
{ send_output("(btool_branch(%d,",Btool_build_number(BTOOL_DO_WHILE, NULL));
|
||
expand_loop_continue_here (); }
|
||
'(' expr ')'
|
||
{ btool_flush_char(1);
|
||
send_output("!=0))");
|
||
}
|
||
';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
expand_exit_loop_if_false (truthvalue_conversion ($7));
|
||
expand_end_loop ();
|
||
clear_momentary (); }
|
||
/* BRANCH */
|
||
| FOR
|
||
'(' xexpr ';'
|
||
{ emit_nop ();
|
||
emit_line_note (input_filename, lineno);
|
||
if ($3) expand_expr_stmt ($3);
|
||
expand_start_loop_continue_elsewhere (1);
|
||
btool_flush_char(1); /* Flush semi */
|
||
send_output("btool_branch(%d,(",Btool_build_number(BTOOL_FOR, NULL));
|
||
}
|
||
xexpr
|
||
{
|
||
if ($6 == NULL_TREE)
|
||
{
|
||
send_output("1");
|
||
}
|
||
send_output(")!=0)");
|
||
}
|
||
';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
if ($6)
|
||
expand_exit_loop_if_false (truthvalue_conversion ($6)); }
|
||
xexpr ')'
|
||
/* Don't let the tree nodes for $10 be discarded
|
||
by clear_momentary during the parsing of the next stmt. */
|
||
{ push_momentary ();
|
||
$<itype>11 = lineno; }
|
||
stmt
|
||
{ emit_line_note (input_filename, $<itype>11);
|
||
expand_loop_continue_here ();
|
||
if ($10)
|
||
expand_expr_stmt ($10);
|
||
pop_momentary ();
|
||
expand_end_loop (); }
|
||
/* BRANCH */
|
||
/* The handling of missing DEFAULT statements is done in function
|
||
'tee_getc' */
|
||
| SWITCH '('
|
||
{ Switch_level++;
|
||
if (Switch_level > 100) {
|
||
if (should_instrument() )
|
||
{
|
||
fprintf(stderr,"Btool: Too many nested switches, switch ignored\n");
|
||
}
|
||
}
|
||
else {
|
||
Switch_default_seen[Switch_level]= 0;
|
||
Switch_brace_level[Switch_level]=0;
|
||
btool_flush_char(1); /* Flush paren */
|
||
send_output("btool_switch((");
|
||
}
|
||
}
|
||
expr ')'
|
||
{ emit_line_note (input_filename, lineno);
|
||
c_expand_start_case ($4);
|
||
/* Don't let the tree nodes for $4 be discarded by
|
||
clear_momentary during the parsing of the next stmt. */
|
||
push_momentary ();
|
||
if (Switch_level < 101) {
|
||
btool_flush_char(1);
|
||
send_output("))");
|
||
}
|
||
}
|
||
stmt
|
||
{ Switch_level--;
|
||
expand_end_case ($4);
|
||
pop_momentary (); }
|
||
/* BRANCH */
|
||
| CASE expr ':'
|
||
{ register tree value = fold ($2);
|
||
register tree label
|
||
= build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
|
||
|
||
if (Switch_level < 101) {
|
||
btool_flush_char(1); /* Flush colon */
|
||
send_output("btool_case(%d);", Btool_build_number(BTOOL_CASE, NULL));
|
||
}
|
||
/* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
|
||
Strip such NOP_EXPRs. */
|
||
if (TREE_CODE (value) == NOP_EXPR
|
||
&& TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
|
||
value = TREE_OPERAND (value, 0);
|
||
|
||
if (TREE_CODE (value) != INTEGER_CST
|
||
&& value != error_mark_node)
|
||
{
|
||
error ("case label does not reduce to an integer constant");
|
||
value = error_mark_node;
|
||
}
|
||
else
|
||
/* Promote char or short to int. */
|
||
value = default_conversion (value);
|
||
if (value != error_mark_node)
|
||
{
|
||
int success = pushcase (value, label);
|
||
if (success == 1)
|
||
error ("case label not within a switch statement");
|
||
else if (success == 2)
|
||
error ("duplicate case value");
|
||
else if (success == 3)
|
||
warning ("case value out of range");
|
||
}
|
||
}
|
||
stmt
|
||
/* BRANCH */
|
||
| DEFAULT ':'
|
||
{
|
||
register tree label
|
||
= build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
|
||
int success = pushcase (NULL_TREE, label);
|
||
if (success == 1)
|
||
error ("default label not within a switch statement");
|
||
else if (success == 2)
|
||
error ("multiple default labels in one switch");
|
||
if (Switch_level < 101) {
|
||
btool_flush_char(1); /* Flush colon */
|
||
send_output("btool_case(%d);", Btool_build_number(BTOOL_DEFAULT, NULL));
|
||
Switch_default_seen[Switch_level]=1;
|
||
}
|
||
}
|
||
stmt
|
||
| BREAK ';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
if ( ! expand_exit_something ())
|
||
error ("break statement not within loop or switch"); }
|
||
| CONTINUE ';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
if (! expand_continue_loop ())
|
||
error ("continue statement not within a loop"); }
|
||
| RETURN ';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
c_expand_return (NULL_TREE); }
|
||
| RETURN expr ';'
|
||
{ emit_line_note (input_filename, lineno);
|
||
c_expand_return ($2); }
|
||
| ASM maybe_type_qual '(' string ')' ';'
|
||
{ if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
|
||
emit_line_note (input_filename, lineno);
|
||
expand_asm ($4); }
|
||
/* This is the case with just output operands. */
|
||
| ASM maybe_type_qual '(' string ':' asm_operands ')' ';'
|
||
{ if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
|
||
emit_line_note (input_filename, lineno);
|
||
c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
|
||
$2 == ridpointers[(int)RID_VOLATILE],
|
||
input_filename, lineno); }
|
||
/* This is the case with input operands as well. */
|
||
| ASM maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';'
|
||
{ if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
|
||
emit_line_note (input_filename, lineno);
|
||
c_expand_asm_operands ($4, $6, $8, NULL_TREE,
|
||
$2 == ridpointers[(int)RID_VOLATILE],
|
||
input_filename, lineno); }
|
||
/* This is the case with clobbered registers as well. */
|
||
| ASM maybe_type_qual '(' string ':' asm_operands ':'
|
||
asm_operands ':' asm_clobbers ')' ';'
|
||
{ if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
|
||
emit_line_note (input_filename, lineno);
|
||
c_expand_asm_operands ($4, $6, $8, $10,
|
||
$2 == ridpointers[(int)RID_VOLATILE],
|
||
input_filename, lineno); }
|
||
| GOTO identifier ';'
|
||
{ tree decl;
|
||
emit_line_note (input_filename, lineno);
|
||
decl = lookup_label ($2);
|
||
TREE_USED (decl) = 1;
|
||
expand_goto (decl); }
|
||
/* BRANCH */
|
||
| identifier ':'
|
||
{ tree label = define_label (input_filename, lineno, $1);
|
||
emit_nop ();
|
||
if (label)
|
||
expand_label (label); }
|
||
stmt
|
||
| ';'
|
||
;
|
||
|
||
/* Either a type-qualifier or nothing. First thing in an `asm' statement. */
|
||
|
||
maybe_type_qual:
|
||
/* empty */
|
||
{ if (pedantic)
|
||
warning ("ANSI C forbids use of `asm' keyword");
|
||
emit_line_note (input_filename, lineno); }
|
||
| TYPE_QUAL
|
||
{ if (pedantic)
|
||
warning ("ANSI C forbids use of `asm' keyword");
|
||
emit_line_note (input_filename, lineno); }
|
||
;
|
||
|
||
xexpr:
|
||
/* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| expr
|
||
;
|
||
|
||
/* These are the operands other than the first string and colon
|
||
in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
|
||
asm_operands: /* empty */
|
||
{ $$ = NULL_TREE; }
|
||
| nonnull_asm_operands
|
||
;
|
||
|
||
nonnull_asm_operands:
|
||
asm_operand
|
||
| nonnull_asm_operands ',' asm_operand
|
||
{ $$ = chainon ($1, $3); }
|
||
;
|
||
|
||
asm_operand:
|
||
STRING '(' expr ')'
|
||
{ $$ = build_tree_list ($1, $3); }
|
||
;
|
||
|
||
asm_clobbers:
|
||
string
|
||
{ $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); }
|
||
| asm_clobbers ',' string
|
||
{ $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); }
|
||
;
|
||
|
||
/* This is what appears inside the parens in a function declarator.
|
||
Its value is a list of ..._TYPE nodes. */
|
||
parmlist:
|
||
{ pushlevel (0);
|
||
declare_parm_level (); }
|
||
parmlist_1
|
||
{ $$ = $2;
|
||
parmlist_tags_warning ();
|
||
poplevel (0, 0, 0); }
|
||
;
|
||
|
||
/* This is referred to where either a parmlist or an identifier list is ok.
|
||
Its value is a list of ..._TYPE nodes or a list of identifiers. */
|
||
parmlist_or_identifiers:
|
||
{ pushlevel (0);
|
||
declare_parm_level (); }
|
||
parmlist_or_identifiers_1
|
||
{ $$ = $2;
|
||
parmlist_tags_warning ();
|
||
poplevel (0, 0, 0); }
|
||
;
|
||
|
||
parmlist_or_identifiers_1:
|
||
parmlist_2 ')'
|
||
| identifiers ')'
|
||
{ $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
|
||
| error ')'
|
||
{ $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
|
||
;
|
||
|
||
parmlist_1:
|
||
parmlist_2 ')'
|
||
| error ')'
|
||
{ $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
|
||
;
|
||
|
||
/* This is what appears inside the parens in a function declarator.
|
||
Is value is represented in the format that grokdeclarator expects. */
|
||
parmlist_2: /* empty */
|
||
{ $$ = get_parm_info (0); }
|
||
| parms
|
||
{ $$ = get_parm_info (1); }
|
||
| parms ',' ELLIPSIS
|
||
{ $$ = get_parm_info (0); }
|
||
;
|
||
|
||
parms:
|
||
parm
|
||
{ push_parm_decl ($1); }
|
||
| parms ',' parm
|
||
{ push_parm_decl ($3); }
|
||
;
|
||
|
||
/* A single parameter declaration or parameter type name,
|
||
as found in a parmlist. */
|
||
parm:
|
||
typed_declspecs parm_declarator
|
||
{ $$ = build_tree_list ($1, $2) ; }
|
||
| typed_declspecs notype_declarator
|
||
{ $$ = build_tree_list ($1, $2) ; }
|
||
| typed_declspecs absdcl
|
||
{ $$ = build_tree_list ($1, $2); }
|
||
| declmods notype_declarator
|
||
{ $$ = build_tree_list ($1, $2) ; }
|
||
| declmods absdcl
|
||
{ $$ = build_tree_list ($1, $2); }
|
||
;
|
||
|
||
/* A nonempty list of identifiers. */
|
||
identifiers:
|
||
IDENTIFIER
|
||
{ $$ = build_tree_list (NULL_TREE, $1); }
|
||
| identifiers ',' IDENTIFIER
|
||
{ $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
|
||
;
|
||
%%
|
||
|
||
/* 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. */
|
||
|
||
static tree
|
||
make_pointer_declarator (type_quals, target)
|
||
tree type_quals, target;
|
||
{
|
||
return build (INDIRECT_REF, type_quals, target);
|
||
}
|
||
|
||
/* Given a chain of STRING_CST nodes,
|
||
concatenate them into one STRING_CST
|
||
and give it a suitable array-of-chars data type. */
|
||
|
||
static tree
|
||
combine_strings (strings)
|
||
tree strings;
|
||
{
|
||
register tree value, t;
|
||
register int length = 1;
|
||
int wide_length = 0;
|
||
int wide_flag = 0;
|
||
|
||
if (TREE_CHAIN (strings))
|
||
{
|
||
/* More than one in the chain, so concatenate. */
|
||
register char *p, *q;
|
||
|
||
/* Don't include the \0 at the end of each substring,
|
||
except for the last one.
|
||
Count wide strings and ordinary strings separately. */
|
||
for (t = strings; t; t = TREE_CHAIN (t))
|
||
{
|
||
if (TREE_TYPE (t) == int_array_type_node)
|
||
{
|
||
wide_length += (TREE_STRING_LENGTH (t) - 1);
|
||
wide_flag = 1;
|
||
}
|
||
else
|
||
length += (TREE_STRING_LENGTH (t) - 1);
|
||
}
|
||
|
||
/* If anything is wide, the non-wides will be converted,
|
||
which makes them take more space. */
|
||
if (wide_flag)
|
||
length = length * UNITS_PER_WORD + wide_length;
|
||
|
||
p = (char *) savealloc (length);
|
||
|
||
/* Copy the individual strings into the new combined string.
|
||
If the combined string is wide, convert the chars to ints
|
||
for any individual strings that are not wide. */
|
||
|
||
q = p;
|
||
for (t = strings; t; t = TREE_CHAIN (t))
|
||
{
|
||
int len = TREE_STRING_LENGTH (t) - 1;
|
||
if ((TREE_TYPE (t) == int_array_type_node) == wide_flag)
|
||
{
|
||
bcopy (TREE_STRING_POINTER (t), q, len);
|
||
q += len;
|
||
}
|
||
else
|
||
{
|
||
int i;
|
||
for (i = 0; i < len; i++)
|
||
((int *) q)[i] = TREE_STRING_POINTER (t)[i];
|
||
q += len * UNITS_PER_WORD;
|
||
}
|
||
}
|
||
*q = 0;
|
||
|
||
value = make_node (STRING_CST);
|
||
TREE_STRING_POINTER (value) = p;
|
||
TREE_STRING_LENGTH (value) = length;
|
||
TREE_LITERAL (value) = 1;
|
||
}
|
||
else
|
||
{
|
||
value = strings;
|
||
length = TREE_STRING_LENGTH (value);
|
||
if (TREE_TYPE (value) == int_array_type_node)
|
||
wide_flag = 1;
|
||
}
|
||
|
||
/* Create the array type for the string constant.
|
||
-Wwrite-strings says make the string constant an array of const char
|
||
so that copying it to a non-const pointer will get a warning. */
|
||
if (warn_write_strings)
|
||
{
|
||
tree elements
|
||
= build_type_variant (wide_flag ? integer_type_node : char_type_node,
|
||
1, 0);
|
||
TREE_TYPE (value)
|
||
= build_array_type (elements,
|
||
build_index_type (build_int_2 (length - 1, 0)));
|
||
}
|
||
else
|
||
TREE_TYPE (value)
|
||
= build_array_type (wide_flag ? integer_type_node : char_type_node,
|
||
build_index_type (build_int_2 (length - 1, 0)));
|
||
TREE_LITERAL (value) = 1;
|
||
TREE_STATIC (value) = 1;
|
||
return value;
|
||
}
|
||
|
||
int lineno; /* current line number in file being read */
|
||
|
||
FILE *finput; /* input file.
|
||
Normally a pipe from the preprocessor. */
|
||
|
||
/* lexical analyzer */
|
||
|
||
int any_ungotten = 0;
|
||
char ungotten_char;
|
||
|
||
int Initialized = 0;
|
||
FILE *Rewritten_output = NULL;
|
||
char *Tempname = (char *)0;
|
||
|
||
/* This routine should be called before exiting to remove the
|
||
temporary file. This is not a great solution, since gcc.c
|
||
already has more reliable mechanisms for doing the same thing. */
|
||
|
||
clean_up_tempfile()
|
||
{
|
||
if (Tempname)
|
||
{
|
||
unlink(Tempname);
|
||
Tempname=(char *)0;
|
||
}
|
||
}
|
||
|
||
|
||
FILE *Mapfile = NULL;
|
||
FILE *Bcountfile = NULL;
|
||
|
||
int Branch_count;
|
||
|
||
/*
|
||
NAME:
|
||
btool_init()
|
||
|
||
extern char *Tempname
|
||
extern FILE *Rewritten_output
|
||
extern int Initialized
|
||
|
||
PURPOSE:
|
||
This routine initializes the needed variables by reading the
|
||
btool_lib.h file and it creates a temporary file for the rewritten
|
||
output. It is called when a new program is going to be instrumented.
|
||
|
||
PRECONDITIONS:
|
||
1. Tempname must be a valid filename
|
||
2. The header file btool_lib.c must be present in the master directory
|
||
3. The information in btool_lib.h must be in the defined format:
|
||
#define NUM_BRANCHES x
|
||
Where x stands for an integer number
|
||
|
||
POSTCONDITIONS:
|
||
The branch_count variable is initialized according to the information
|
||
in btool_lib.h. The map file is opened. The temporary file for the
|
||
rewritten output is created. The initialized flag is set to 1 in order
|
||
to indicate that the initalization was done for this particular file.
|
||
|
||
ERRORS:
|
||
1. If it is not possible to create the temporary file specified with
|
||
tempname, the program will use the fatal function to write an error
|
||
message to stderr and to quit.
|
||
2. If the routine can't find the header file it will will use the
|
||
fatal function to write an error message to stderr and
|
||
to quit.
|
||
3. If btool_lib.h does not contain the #define NUM_BRANCH statement,
|
||
the routine will use the fatal function to wirte an error message
|
||
to stderr and to quit.
|
||
*/
|
||
|
||
btool_init()
|
||
{
|
||
FILE *tempfile;
|
||
char buf[PATH_BUF_LEN];
|
||
char buf1[PATH_BUF_LEN];
|
||
int fd;
|
||
|
||
Initialized = 1;
|
||
|
||
Tempname = tempnam(NULL, "btool");
|
||
if (NULL == Tempname)
|
||
{
|
||
fatal("Can't generate unique filename for temporary file.\n");
|
||
}
|
||
|
||
Rewritten_output = fopen(Tempname, "w");
|
||
/* Note: if we fail to delete this temporary file, gcc will. */
|
||
|
||
/* fprintf(stderr, "Rewritten output in %s\n", Tempname); */
|
||
|
||
if (NULL == Rewritten_output)
|
||
{
|
||
fatal("Can't open file %s\n", Tempname);
|
||
}
|
||
#ifdef sgi
|
||
/* output function prototypes for btool functions */
|
||
fprintf(Rewritten_output, "extern long btool_branch(unsigned long, long);\n");
|
||
fprintf(Rewritten_output, "extern void btool_func(unsigned long);\n");
|
||
fprintf(Rewritten_output, "extern long btool_switch(long);\n");
|
||
fprintf(Rewritten_output, "extern void btool_case(unsigned long);\n");
|
||
#endif
|
||
|
||
|
||
|
||
/* Mapfile = fopen(Mapfile_name, "a"); */
|
||
|
||
strcpy(buf1,Dir_name);
|
||
strcat(buf1,"/");
|
||
strcat(buf1,Mapfile_name);
|
||
|
||
strcpy(buf,Dir_name);
|
||
strcat(buf,"/");
|
||
strcat(buf,Countfile_name);
|
||
if ((Bcountfile = fopen(buf, "r+")) == NULL) {
|
||
if ((fd = open(buf, O_RDWR|O_CREAT|O_EXCL, 0666)) < 0) {
|
||
if (errno != EEXIST)
|
||
fatal("Can't open file %s\n", buf);
|
||
/* file now exists - we should be able to open it */
|
||
if ((Bcountfile = fopen(buf, "r+")) == NULL)
|
||
fatal("Can't open file %s\n", buf);
|
||
} else {
|
||
/* we created it ... */
|
||
if ((Bcountfile = fdopen(fd, "r+")) == NULL)
|
||
fatal("Can't open file %s\n", buf);
|
||
}
|
||
}
|
||
setlinebuf(Bcountfile);
|
||
|
||
Mapfile = fopen(buf1, "a");
|
||
setlinebuf(Mapfile);
|
||
|
||
/* fprintf(stderr,"%s\n",buf);
|
||
fprintf(stderr,"%s\n",buf1); */
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
NAME:
|
||
btool_finish()
|
||
|
||
extern char *Tempname
|
||
extern FILE *Rewritten_output
|
||
extern char *main_input_filename
|
||
|
||
PURPOSE:
|
||
This routine is called when the EOF char of the original input
|
||
file is recognized by the lexical analyzer. Therefore, its purpose is
|
||
to write out the information obtained by processing the input file.
|
||
This includes the following steps:
|
||
It closes the map file and the Rewritten_output file. The
|
||
rewritten output file is renamed so that it has the same name as the
|
||
original input file. Furthermore, the macro start/end markers from the
|
||
preprocessor are stripped out in order to have the rewritten output be
|
||
compatible with any C compiler.
|
||
It also writes out the new headerfile btool_lib.h. In addition it
|
||
sets the initialized flag to 0 which forces the btool_init routine
|
||
to be called when a new file is going to be instrumented.
|
||
|
||
PRECONDITIONS:
|
||
1. The rewritten output file must be open.
|
||
2. The mapfile must be open.
|
||
3. It must be possible to write all data to the header file.
|
||
4. It must be possible to rename the temporary file.
|
||
5. It must be possible to allocate space for the sed command string
|
||
buffer
|
||
|
||
POSTCONDITIONS:
|
||
The initialized flag is equal to 0. The map file is closed. The
|
||
rewritten output (instrumented code) has replaced the original input
|
||
file and is free of any macro markers inserted by the preprocessor.
|
||
The btool_lib.h file is up-to-date.
|
||
|
||
ERRORS:
|
||
1. - 4. are not checked (caller's responsibility)
|
||
5. The routine will issue an error message using GCC's fatal
|
||
routine and quit.
|
||
*/
|
||
|
||
btool_finish()
|
||
{
|
||
FILE *tempfile;
|
||
char *basename;
|
||
char *buffer;
|
||
extern char* strrchr();
|
||
extern char *main_input_filename;
|
||
char buf[PATH_BUF_LEN];
|
||
extern char *asm_file_name;
|
||
char *sasm;
|
||
int slen;
|
||
|
||
if (Initialized)
|
||
{
|
||
Initialized = 0;
|
||
|
||
fclose(Rewritten_output);
|
||
|
||
#ifdef sgi
|
||
buffer = (char *) malloc(100+strlen(Tempname) + strlen(asm_file_name));
|
||
if ((char *)0 == buffer)
|
||
{
|
||
fatal("Not enough memory for output buffer\n");
|
||
}
|
||
else
|
||
{
|
||
sasm = strdup(asm_file_name);
|
||
slen = strlen(sasm);
|
||
if (strcmp(&sasm[slen - 2], ".s") == 0)
|
||
sasm[slen - 2] = '\0';
|
||
|
||
sprintf(buffer, "/bin/sed -e '/^#[ ]*pragma[ ]*btool_/d' -e '/^#start_btool/d' -e '/^#end_btool/d' < %s > %s_btool.c\n", Tempname,sasm);
|
||
if (0 != system(buffer))
|
||
{
|
||
error("Couldn't replace original source with instrumented source.\n");
|
||
fatal("Failed: %s\n", buffer);
|
||
}
|
||
clean_up_tempfile();
|
||
free(buffer);
|
||
free(sasm);
|
||
}
|
||
#else
|
||
buffer = (char *) malloc(100+strlen(Tempname) + strlen(main_input_filename));
|
||
if ((char *)0 == buffer)
|
||
{
|
||
fatal("Not enough memory for output buffer\n");
|
||
}
|
||
else
|
||
{
|
||
if (-1 == unlink(main_input_filename))
|
||
{
|
||
perror("unlink: ");
|
||
fatal("Couldn't unlink old version of %s.\n", main_input_filename);
|
||
}
|
||
sprintf(buffer, "/bin/sed -e '/^#[ ]*pragma[ ]*btool_/d' -e '/^#start_btool/d' -e '/^#end_btool/d' < %s > %s\n", Tempname,main_input_filename);
|
||
if (0 != system(buffer))
|
||
{
|
||
error("Couldn't replace original source with instrumented source.\n");
|
||
fatal("Failed: %s\n", buffer);
|
||
}
|
||
clean_up_tempfile();
|
||
free(buffer);
|
||
}
|
||
#endif
|
||
|
||
|
||
fclose(Mapfile);
|
||
|
||
|
||
#ifndef sgi
|
||
strcpy(buf,Dir_name);
|
||
strcat(buf,"/btool_lib.h");
|
||
|
||
tempfile = fopen(buf, "w");
|
||
|
||
fprintf(tempfile, "#define NUM_BRANCHES %d\n", Branch_count);
|
||
fclose(tempfile);
|
||
#endif
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
int any_to_print = 0;
|
||
char to_print_char;
|
||
|
||
#define GOTCHAR(c) {any_to_print = 1; to_print_char = c;}
|
||
#define NOCHAR {any_to_print=0;}
|
||
|
||
#ifdef sgi
|
||
char func_head_buf[5000];
|
||
char *fhp = NULL;
|
||
int infunc;
|
||
int Func_number;
|
||
|
||
start_func()
|
||
{
|
||
if (!should_instrument())
|
||
return;
|
||
|
||
#ifdef DEBUG
|
||
fprintf(stderr, "BRANCH: starting %s to print %c any %d\n",
|
||
DECL_PRINT_NAME(current_function_decl),
|
||
to_print_char, any_to_print);
|
||
#endif
|
||
|
||
fhp = func_head_buf;
|
||
*fhp = '\0';
|
||
if (any_to_print) {
|
||
*fhp++ = to_print_char;
|
||
NOCHAR;
|
||
}
|
||
/*btool_flush_char(0);*/
|
||
if (infunc)
|
||
warning("BRANCH:infunc already 1 when encountered %s",
|
||
DECL_PRINT_NAME(current_function_decl));
|
||
infunc = 1;
|
||
|
||
Func_number = Btool_build_number(BTOOL_FUNC,
|
||
DECL_PRINT_NAME(current_function_decl));
|
||
|
||
}
|
||
|
||
end_func()
|
||
{
|
||
int i;
|
||
char *semi, *tp;
|
||
char c;
|
||
|
||
if (infunc == 0)
|
||
return;
|
||
infunc = 0;
|
||
|
||
#ifdef DEBUG
|
||
fprintf(stderr, "BRANCH: ending %s to print %c any %d\n",
|
||
DECL_PRINT_NAME(current_function_decl),
|
||
to_print_char, any_to_print);
|
||
#endif
|
||
*fhp = '\0';
|
||
|
||
for (semi = fhp; semi >= func_head_buf; semi--)
|
||
if (*semi == ';' || *semi == '{')
|
||
break;
|
||
if (semi < func_head_buf) {
|
||
warning("BRANCH:no trailing ';' or '{' in %s",
|
||
DECL_PRINT_NAME(current_function_decl));
|
||
#ifdef DEBUG
|
||
fprintf(stderr, "BRANCH:fhp 0x%x func_head_buf 0x%x: <%s>\n",
|
||
fhp, &func_head_buf, func_head_buf);
|
||
#endif
|
||
}
|
||
c = *semi;
|
||
*semi = '\0';
|
||
fwrite(func_head_buf, semi - func_head_buf, 1, Rewritten_output);
|
||
|
||
fprintf(Rewritten_output, "%c\n\tbtool_func(%d);\n", c, Func_number);
|
||
Func_number = 0;
|
||
|
||
/* output rest of characters */
|
||
for (tp = semi + 1; tp < fhp; tp++)
|
||
putc(*tp, Rewritten_output);
|
||
fhp = NULL;
|
||
}
|
||
#endif
|
||
|
||
|
||
/*
|
||
NAME:
|
||
btool_flush_char()
|
||
|
||
extern int any_to_print
|
||
extern char to_print_char
|
||
extern FILE *Rewritten_output
|
||
|
||
PURPOSE:
|
||
If the look ahead buffer of the lexical analyzer contains a char this
|
||
char is written to the rewritten output. This is needed because:
|
||
1. This is how the original source file is copied to the rewritten
|
||
output file
|
||
2. When the parser inserts its library routine calls it is necessary
|
||
to have this look ahead char written out. Otherwise it would not
|
||
produce syntactically correct code.
|
||
|
||
PRECONDITIONS:
|
||
1. any_to_print must have a boolean value (0 or 1)
|
||
|
||
POSTCONDITIONS:
|
||
If a char is in the look ahead buffer which means that any_to_print
|
||
is equal to 1, the char is written out and the any_to_print flag is
|
||
set to 0. If any_to_print is equal to 0 nothing happens.
|
||
|
||
ERRORS:
|
||
1. It is not checked if any_to_print is 0 or 1.
|
||
|
||
INTERNAL ERRORS:
|
||
1. It is not checked whether the write of the char was successfull.
|
||
*/
|
||
|
||
btool_flush_char(error_if_none)
|
||
int error_if_none; /* Caller expects character there. */
|
||
{
|
||
if (any_to_print)
|
||
{
|
||
if (EOF != to_print_char)
|
||
{
|
||
#ifdef sgi
|
||
if (infunc) {
|
||
*fhp++ = to_print_char;
|
||
} else
|
||
#endif
|
||
putc(to_print_char, Rewritten_output);
|
||
}
|
||
any_to_print = 0;
|
||
}
|
||
else if (error_if_none)
|
||
{
|
||
fprintf(stderr, "Branch failure -- no character to print.\n");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* Don't want to output characters before they're used by the parser, so
|
||
* that the parser can insert its output before them. For example, when
|
||
* lexing
|
||
*
|
||
* if(
|
||
*
|
||
* don't want to print the '(' before the parser inserts its output.
|
||
*/
|
||
|
||
|
||
/*
|
||
NAME:
|
||
tee_getc(finput)
|
||
FILE *finput
|
||
|
||
|
||
extern int Switch_level
|
||
extern int Switch_brace_level[]
|
||
extern int Switch_default_seen[]
|
||
extern int any_ungotten
|
||
extern char ungotten_char
|
||
|
||
PURPOSE:
|
||
This routine simulates the getc routine. If a char is ungotten (the
|
||
ungotten flag equal 1 in this case) this char is returned otherwise a
|
||
char is read from finput. In addition it calles btool_init if necessary
|
||
(if the initialized flag is equal to 0) and it calles btool_finish if
|
||
EOF is reached. It also adds a default case together with its needed
|
||
instrumentation to a switch statement if this particular switch does
|
||
not contain a default case. This can not be done in the grammer because
|
||
the grammer actualy does not need curly braces ({}).
|
||
|
||
PRECONDITIONS:
|
||
1. switch_brace_level[] is non-NULL
|
||
2. switch_default_seen[] is non-NULL
|
||
3. finput is a valid, open file.
|
||
|
||
POSTCODITIONS:
|
||
A char is read either from finput or from the ungotten_char variable
|
||
and any_to_print equals 1. The rewritten output file contains in
|
||
addition to the code read from finput a default case an the necessary
|
||
instrumentation for that case if a switch statement was encountered
|
||
that had no default case. The return code is the char read.
|
||
|
||
ERRORS:
|
||
1. - 3. are not checked. (Caller's responsibility)
|
||
|
||
INTERNAL ERRORS:
|
||
1. The routine returns an error message on stderr if switch_level > 100
|
||
2. The routine does what getc does if a read error is encountered
|
||
*/
|
||
|
||
tee_getc (finput)
|
||
FILE *finput;
|
||
{
|
||
char c;
|
||
|
||
if (! Initialized) btool_init();
|
||
|
||
if (any_ungotten)
|
||
{
|
||
c = ungotten_char;
|
||
any_ungotten = 0;
|
||
GOTCHAR(c);
|
||
}
|
||
else
|
||
{
|
||
btool_flush_char(0);
|
||
c = getc(finput);
|
||
if (EOF == c)
|
||
{
|
||
btool_finish();
|
||
}
|
||
GOTCHAR(c);
|
||
if ((Switch_level > 0) && (Switch_level < 101))
|
||
{
|
||
switch (c)
|
||
{
|
||
case '{':
|
||
Switch_brace_level[Switch_level]++;
|
||
break;
|
||
case '}':
|
||
if ( 1 == Switch_brace_level[Switch_level]
|
||
&& !Switch_default_seen[Switch_level])
|
||
{
|
||
send_output("default: btool_case(%d); break;",
|
||
Btool_build_number(BTOOL_DEFAULT, NULL));
|
||
}
|
||
Switch_brace_level[Switch_level]--;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return c;
|
||
|
||
}
|
||
|
||
/*
|
||
NAME:
|
||
tee_ungetc(c,finput)
|
||
char c
|
||
FILE *finput
|
||
|
||
extern int any_ungotten
|
||
extern char ungotten_char
|
||
|
||
PURPOSE:
|
||
This routine simulates the ungetc routine. It ungets a char from
|
||
finput.
|
||
|
||
PRECONDITIONS:
|
||
1. The input must come from one file. The routine does not work with
|
||
multiple files.
|
||
|
||
POSTCONDITIONS:
|
||
One char is ungotten and stored in variable ungotten_char. The
|
||
any_ungotten flag equals 1. The ungotten char is not put back to
|
||
finput.
|
||
|
||
ERRORS:
|
||
1. This is not checked. (caller's responsibility)
|
||
*/
|
||
|
||
tee_ungetc(c, finput)
|
||
{
|
||
NOCHAR;
|
||
any_ungotten = 1;
|
||
ungotten_char = c;
|
||
}
|
||
|
||
/* END BRANCH */
|
||
|
||
static int maxtoken; /* Current nominal length of token buffer. */
|
||
static char *token_buffer; /* Pointer to token buffer.
|
||
Actual allocated length is maxtoken + 2. */
|
||
static int max_wide; /* Current nominal length of wide_buffer. */
|
||
static int *wide_buffer; /* Pointer to wide-string buffer.
|
||
Actual allocated length is max_wide + 1. */
|
||
|
||
/* Nonzero if end-of-file has been seen on input. */
|
||
static int end_of_file;
|
||
|
||
/* Data type that represents the GNU C reserved words. */
|
||
struct resword { char *name; short token; enum rid rid; };
|
||
|
||
#define MIN_WORD_LENGTH 2 /* minimum size for C keyword */
|
||
#define MAX_WORD_LENGTH 13 /* maximum size for C keyword */
|
||
#define MIN_HASH_VALUE 7 /* range of the hash keys values */
|
||
#define MAX_HASH_VALUE 91 /* for the perfect hash generator */
|
||
#define NORID RID_UNUSED
|
||
|
||
/* This function performs the minimum-perfect hash mapping from input
|
||
string to reswords table index. It only looks at the first and
|
||
last characters in the string, thus assuring the O(1) lookup time
|
||
(this keeps our constant down to an insignificant amount!). Compiling
|
||
the following 2 functions as inline removes all overhead of the
|
||
function calls. */
|
||
|
||
#ifdef __GNUC__
|
||
__inline
|
||
#endif
|
||
static int
|
||
hash (str, len)
|
||
register char *str;
|
||
register int len;
|
||
{
|
||
/* This table is used to build the hash table index that recognizes
|
||
reserved words in 0(1) steps. It is larger than strictly necessary,
|
||
but I'm trading off the space for the time-saving luxury of avoiding
|
||
subtraction of an offset. All those ``91's'' (actually just a
|
||
short-hand for MAX_HASH_VALUE #defined above) are used to speed up
|
||
the search when the string found on the input stream doesn't have a
|
||
first or last character that is part of the set of alphabetic
|
||
characters that comprise the first or last characters in C
|
||
reserved words. */
|
||
|
||
static int hash_table[] =
|
||
{
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
|
||
91, 91, 91, 91, 91, 1, 91, 2, 1, 32,
|
||
7, 5, 18, 20, 1, 17, 91, 1, 18, 1,
|
||
28, 1, 23, 91, 12, 20, 1, 41, 7, 15,
|
||
91, 91, 10, 91, 91, 91, 91, 91,
|
||
};
|
||
register int hval = len ;
|
||
|
||
switch (hval)
|
||
{
|
||
default:
|
||
case 3:
|
||
hval += hash_table[str[2]];
|
||
case 2:
|
||
case 1:
|
||
return hval + hash_table[str[0]] + hash_table[str[len - 1]];
|
||
}
|
||
}
|
||
|
||
/* This routine attempts to match the string found in the reswords table
|
||
with the one from the input stream. If all the relevant details
|
||
match then an actual strcmp comparison is performed and the address of
|
||
correct struct resword entry is returned. Otherwise, a NULL
|
||
pointer is returned. */
|
||
|
||
#ifdef __GNUC__
|
||
__inline
|
||
#endif
|
||
struct resword *
|
||
is_reserved_word (str, len)
|
||
register char *str;
|
||
register int len;
|
||
{
|
||
/* This is the hash table of keywords.
|
||
The order of keywords has been chosen for perfect hashing.
|
||
Therefore, this table cannot be updated by hand.
|
||
Use the program ``gperf,'' available with the latest libg++
|
||
distribution, to generate an updated table. A file called
|
||
c-parse.gperf, distributed with GNU C, contains the keyword file. */
|
||
|
||
static struct resword reswords[] =
|
||
{
|
||
{ "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", },
|
||
{"asm", ASM, NORID },
|
||
{"auto", SCSPEC, RID_AUTO },
|
||
{"__asm", ASM, NORID },
|
||
{"do", DO, NORID },
|
||
{"__asm__", ASM, NORID },
|
||
{"break", BREAK, NORID },
|
||
{"__typeof__", TYPEOF, NORID },
|
||
{ "", },
|
||
{"__alignof__", ALIGNOF, NORID },
|
||
{ "", },
|
||
{"__attribute__", ATTRIBUTE, NORID },
|
||
{ "", },
|
||
{"__attribute", ATTRIBUTE, NORID },
|
||
{ "", },
|
||
{"__volatile__", TYPE_QUAL, RID_VOLATILE },
|
||
{"int", TYPESPEC, RID_INT },
|
||
{"__volatile", TYPE_QUAL, RID_VOLATILE },
|
||
{ "", },
|
||
{"float", TYPESPEC, RID_FLOAT },
|
||
{"goto", GOTO, NORID },
|
||
{"short", TYPESPEC, RID_SHORT },
|
||
{"__typeof", TYPEOF, NORID },
|
||
{"__inline__", SCSPEC, RID_INLINE },
|
||
{"__alignof", ALIGNOF, NORID },
|
||
{"__inline", SCSPEC, RID_INLINE },
|
||
{"__signed__", TYPESPEC, RID_SIGNED },
|
||
{"default", DEFAULT, NORID },
|
||
{"else", ELSE, NORID },
|
||
{"void", TYPESPEC, RID_VOID },
|
||
{"__signed", TYPESPEC, RID_SIGNED },
|
||
{"if", IF, NORID },
|
||
{"volatile", TYPE_QUAL, RID_VOLATILE },
|
||
{"struct", STRUCT, NORID },
|
||
{"extern", SCSPEC, RID_EXTERN },
|
||
{"__const", TYPE_QUAL, RID_CONST },
|
||
{"while", WHILE, NORID },
|
||
{"__const__", TYPE_QUAL, RID_CONST },
|
||
{"switch", SWITCH, NORID },
|
||
{"for", FOR, NORID },
|
||
{"inline", SCSPEC, RID_INLINE },
|
||
{"return", RETURN, NORID },
|
||
{"typeof", TYPEOF, NORID },
|
||
{"typedef", SCSPEC, RID_TYPEDEF },
|
||
{"char", TYPESPEC, RID_CHAR },
|
||
{"enum", ENUM, NORID },
|
||
{"register", SCSPEC, RID_REGISTER },
|
||
{"signed", TYPESPEC, RID_SIGNED },
|
||
{"sizeof", SIZEOF, NORID },
|
||
{ "", }, { "", }, { "", }, { "", },
|
||
{"double", TYPESPEC, RID_DOUBLE },
|
||
{"static", SCSPEC, RID_STATIC },
|
||
{"case", CASE, NORID },
|
||
{ "", }, { "", }, { "", }, { "", },
|
||
{"const", TYPE_QUAL, RID_CONST },
|
||
{ "", }, { "", }, { "", },
|
||
{"long", TYPESPEC, RID_LONG },
|
||
{ "", }, { "", },
|
||
{"continue", CONTINUE, NORID },
|
||
{ "", }, { "", },
|
||
{"unsigned", TYPESPEC, RID_UNSIGNED },
|
||
{ "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", },
|
||
{ "", }, { "", }, { "", }, { "", }, { "", },
|
||
{"union", UNION, NORID },
|
||
};
|
||
|
||
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
|
||
{
|
||
register int key = hash (str, len);
|
||
|
||
if (key <= MAX_HASH_VALUE)
|
||
{
|
||
register char *s = reswords[key].name;
|
||
|
||
if (*s == *str && !strcmp (str + 1, s + 1))
|
||
return &reswords[key];
|
||
}
|
||
}
|
||
if (*str == '_' && !strcmp(str+1, "_builtin_alignof"))
|
||
return &reswords[15];
|
||
return 0;
|
||
}
|
||
|
||
/* 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];
|
||
|
||
int check_newline ();
|
||
|
||
void
|
||
init_lex ()
|
||
{
|
||
/* Start it at 0, because check_newline is called at the very beginning
|
||
and will increment it to 1. */
|
||
lineno = 0;
|
||
|
||
maxtoken = 40;
|
||
token_buffer = (char *) xmalloc (maxtoken + 2);
|
||
max_wide = 40;
|
||
wide_buffer = (int *) xmalloc (max_wide + 1);
|
||
|
||
ridpointers[(int) RID_INT] = get_identifier ("int");
|
||
ridpointers[(int) RID_CHAR] = get_identifier ("char");
|
||
ridpointers[(int) RID_VOID] = get_identifier ("void");
|
||
ridpointers[(int) RID_FLOAT] = get_identifier ("float");
|
||
ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
|
||
ridpointers[(int) RID_SHORT] = get_identifier ("short");
|
||
ridpointers[(int) RID_LONG] = get_identifier ("long");
|
||
ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
|
||
ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
|
||
ridpointers[(int) RID_INLINE] = get_identifier ("inline");
|
||
ridpointers[(int) RID_CONST] = get_identifier ("const");
|
||
ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
|
||
ridpointers[(int) RID_AUTO] = get_identifier ("auto");
|
||
ridpointers[(int) RID_STATIC] = get_identifier ("static");
|
||
ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
|
||
ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
|
||
ridpointers[(int) RID_REGISTER] = get_identifier ("register");
|
||
}
|
||
|
||
static void
|
||
reinit_parse_for_function ()
|
||
{
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
#if 0
|
||
register int inside;
|
||
#endif
|
||
|
||
for (;;)
|
||
{
|
||
switch (c)
|
||
{
|
||
/* Don't recognize comments in cc1: all comments are removed by cpp,
|
||
and cpp output can include / and * consecutively as operators. */
|
||
#if 0
|
||
case '/':
|
||
c = tee_getc (finput);
|
||
if (c != '*')
|
||
{
|
||
tee_ungetc (c, finput);
|
||
return '/';
|
||
}
|
||
|
||
c = tee_getc (finput);
|
||
|
||
inside = 1;
|
||
while (inside)
|
||
{
|
||
if (c == '*')
|
||
{
|
||
while (c == '*')
|
||
c = tee_getc (finput);
|
||
|
||
if (c == '/')
|
||
{
|
||
inside = 0;
|
||
c = tee_getc (finput);
|
||
}
|
||
}
|
||
else if (c == '\n')
|
||
{
|
||
lineno++;
|
||
c = tee_getc (finput);
|
||
}
|
||
else if (c == EOF)
|
||
{
|
||
error ("unterminated comment");
|
||
break;
|
||
}
|
||
else
|
||
c = tee_getc (finput);
|
||
}
|
||
|
||
break;
|
||
#endif
|
||
|
||
case '\n':
|
||
c = check_newline ();
|
||
break;
|
||
|
||
case ' ':
|
||
case '\t':
|
||
case '\f':
|
||
case '\r':
|
||
case '\v':
|
||
case '\b':
|
||
c = tee_getc (finput);
|
||
break;
|
||
|
||
case '\\':
|
||
c = tee_getc (finput);
|
||
if (c == '\n')
|
||
lineno++;
|
||
else
|
||
error ("stray '\\' in program");
|
||
c = tee_getc (finput);
|
||
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;
|
||
}
|
||
|
||
/* 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
|
||
check_newline ()
|
||
{
|
||
register int c;
|
||
register int token;
|
||
|
||
lineno++;
|
||
|
||
/* Read first nonwhite char on the line. */
|
||
|
||
c = tee_getc (finput);
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
|
||
if (c != '#')
|
||
{
|
||
/* If not #, return it so caller will use it. */
|
||
return c;
|
||
}
|
||
|
||
/* Read first nonwhite char after the `#'. */
|
||
|
||
c = tee_getc (finput);
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
|
||
/* 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'))
|
||
{
|
||
/* BRANCH : recognize start_btool & end_btool */
|
||
|
||
if (c == 's')
|
||
{
|
||
if (tee_getc (finput) == 't'
|
||
&& tee_getc (finput) == 'a'
|
||
&& tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 't'
|
||
&& tee_getc (finput) == '_'
|
||
&& tee_getc (finput) == 'b'
|
||
&& tee_getc (finput) == 't'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'l'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
Inside_macro = 1;
|
||
goto skipline;
|
||
}
|
||
}
|
||
|
||
if (c == 'e')
|
||
{
|
||
if (tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 'd'
|
||
&& tee_getc (finput) == '_'
|
||
&& tee_getc (finput) == 'b'
|
||
&& tee_getc (finput) == 't'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'l'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
Inside_macro = 0;
|
||
Function_in_macro = 0; /* No longer defining macro in func. */
|
||
goto skipline;
|
||
}
|
||
}
|
||
|
||
if (c == 'd')
|
||
{
|
||
if (tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'f'
|
||
&& tee_getc (finput) == 'i'
|
||
&& tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 'e'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
goto skipline;
|
||
}
|
||
|
||
if (c == 'p')
|
||
{
|
||
if (tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 'a'
|
||
&& tee_getc (finput) == 'g'
|
||
&& tee_getc (finput) == 'm'
|
||
&& tee_getc (finput) == 'a'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
/*
|
||
* BRANCH: Add our four pragmas. Note: can't use yylex
|
||
* because it swallows up the trailing newline. Note also
|
||
* that if the user truncates a pragma, error handling will
|
||
* swallow up the entire next line. This is ugly, but
|
||
* consistent with the way all other #-directives work.
|
||
*/
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
if (c == 'b')
|
||
{
|
||
if (tee_getc (finput) == 't'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'l'
|
||
&& tee_getc (finput) == '_')
|
||
{
|
||
if ((c = tee_getc (finput)) == 'f')
|
||
{
|
||
if (tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 'c'
|
||
&& tee_getc (finput) == 'e'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
User_force = 1;
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'p')
|
||
{
|
||
if (tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'v'
|
||
&& tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 't'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
User_prevent = 1;
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'u'
|
||
&& tee_getc (finput) == 'n')
|
||
{
|
||
if ((c = tee_getc (finput)) == 'f')
|
||
{
|
||
if (tee_getc (finput) == 'o'
|
||
&& tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 'c'
|
||
&& tee_getc (finput) == 'e'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
User_force = 0;
|
||
goto skipline;
|
||
}
|
||
}
|
||
else if (c == 'p')
|
||
{
|
||
if (tee_getc (finput) == 'r'
|
||
&& tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'v'
|
||
&& tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 't'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t' || c == '\n'))
|
||
{
|
||
User_prevent = 0;
|
||
goto skipline;
|
||
}
|
||
}
|
||
}
|
||
error ("Unknown btool pragma");
|
||
goto skipline;
|
||
}
|
||
}
|
||
goto skipline;
|
||
}
|
||
}
|
||
|
||
else if (c == 'l')
|
||
{
|
||
if (tee_getc (finput) == 'i'
|
||
&& tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 'e'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t'))
|
||
goto linenum;
|
||
}
|
||
else if (c == 'i')
|
||
{
|
||
if (tee_getc (finput) == 'd'
|
||
&& tee_getc (finput) == 'e'
|
||
&& tee_getc (finput) == 'n'
|
||
&& tee_getc (finput) == 't'
|
||
&& ((c = tee_getc (finput)) == ' ' || c == '\t'))
|
||
{
|
||
extern FILE *asm_out_file;
|
||
|
||
if (pedantic)
|
||
error ("ANSI C does not allow #ident");
|
||
|
||
/* Here we have just seen `#ident '.
|
||
A string constant should follow. */
|
||
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
|
||
/* If no argument, ignore the line. */
|
||
if (c == '\n')
|
||
return c;
|
||
|
||
tee_ungetc (c, finput);
|
||
token = yylex ();
|
||
if (token != STRING
|
||
|| TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #ident");
|
||
goto skipline;
|
||
}
|
||
|
||
#ifdef ASM_OUTPUT_IDENT
|
||
ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
|
||
#endif
|
||
|
||
/* Skip the rest of this line. */
|
||
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 = tee_getc (finput);
|
||
|
||
/* If the # is the only nonwhite char on the line,
|
||
just ignore it. Check the new newline. */
|
||
if (c == '\n')
|
||
return c;
|
||
|
||
/* Something follows the #; read a token. */
|
||
|
||
tee_ungetc (c, finput);
|
||
token = yylex ();
|
||
|
||
if (token == CONSTANT
|
||
&& TREE_CODE (yylval.ttype) == INTEGER_CST)
|
||
{
|
||
int old_lineno = lineno;
|
||
/* subtract one, because it is the following line that
|
||
gets the specified number */
|
||
|
||
int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
|
||
|
||
/* Is this the last nonwhite stuff on the line? */
|
||
c = tee_getc (finput);
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
if (c == '\n')
|
||
{
|
||
/* No more: store the line number and check following line. */
|
||
lineno = l;
|
||
return c;
|
||
}
|
||
tee_ungetc (c, finput);
|
||
|
||
/* More follows: it must be a string constant (filename). */
|
||
|
||
token = yylex ();
|
||
if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
|
||
{
|
||
error ("invalid #line");
|
||
goto skipline;
|
||
}
|
||
|
||
input_filename
|
||
= (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
|
||
strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
|
||
lineno = l;
|
||
|
||
if (main_input_filename == 0)
|
||
main_input_filename = input_filename;
|
||
|
||
/* Is this the last nonwhite stuff on the line? */
|
||
c = tee_getc (finput);
|
||
while (c == ' ' || c == '\t')
|
||
c = tee_getc (finput);
|
||
if (c == '\n')
|
||
return c;
|
||
tee_ungetc (c, finput);
|
||
|
||
token = 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)
|
||
{
|
||
struct file_stack *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++;
|
||
}
|
||
else if (input_file_stack->next)
|
||
{
|
||
struct file_stack *p = input_file_stack;
|
||
input_file_stack = p->next;
|
||
free (p);
|
||
input_file_stack_tick++;
|
||
}
|
||
else
|
||
error ("#-lines for entering and leaving files don't match");
|
||
}
|
||
}
|
||
else
|
||
error ("invalid #-line");
|
||
|
||
/* skip the rest of this line. */
|
||
skipline:
|
||
if (c == '\n')
|
||
return c;
|
||
while ((c = tee_getc (finput)) != EOF && c != '\n');
|
||
return c;
|
||
}
|
||
|
||
#define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
|
||
#define isdigit(char) (char >= '0' && char <= '9')
|
||
#define ENDFILE -1 /* token that represents end-of-file */
|
||
|
||
|
||
static int
|
||
readescape ()
|
||
{
|
||
register int c = tee_getc (finput);
|
||
register int count, code;
|
||
int firstdig;
|
||
|
||
switch (c)
|
||
{
|
||
case 'x':
|
||
code = 0;
|
||
count = 0;
|
||
while (1)
|
||
{
|
||
c = tee_getc (finput);
|
||
if (!(c >= 'a' && c <= 'f')
|
||
&& !(c >= 'A' && c <= 'F')
|
||
&& !(c >= '0' && c <= '9'))
|
||
{
|
||
tee_ungetc (c, finput);
|
||
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 (count == 0)
|
||
firstdig = code;
|
||
count++;
|
||
}
|
||
if (count == 0)
|
||
error ("\\x used with no following hex digits");
|
||
else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
|
||
|| ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
|
||
<= firstdig))
|
||
warning ("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 = tee_getc (finput);
|
||
}
|
||
tee_ungetc (c, finput);
|
||
return code;
|
||
|
||
case '\\': case '\'': case '"':
|
||
return c;
|
||
|
||
case '\n':
|
||
lineno++;
|
||
return -1;
|
||
|
||
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':
|
||
return TARGET_BELL;
|
||
|
||
case 'v':
|
||
return TARGET_VT;
|
||
|
||
case 'E':
|
||
return 033;
|
||
|
||
case '?':
|
||
/* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
|
||
case '(':
|
||
case '{':
|
||
case '[':
|
||
return c;
|
||
}
|
||
if (c >= 040 && c <= 0177)
|
||
warning ("unknown escape sequence `\\%c'", c);
|
||
else
|
||
warning ("unknown escape sequence: `\\' followed by char code 0x%x", c);
|
||
return c;
|
||
}
|
||
|
||
void
|
||
yyerror (string)
|
||
char *string;
|
||
{
|
||
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, " 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 || token_buffer[0] >= 0177)
|
||
sprintf (buf + strlen (buf), " before character 0%o", token_buffer[0]);
|
||
else
|
||
strcat (buf, " before `%s'");
|
||
|
||
error (buf, token_buffer);
|
||
}
|
||
|
||
static int nextchar = -1;
|
||
|
||
static int
|
||
yylex ()
|
||
{
|
||
register int c;
|
||
register char *p;
|
||
register int value;
|
||
int wide_flag = 0;
|
||
|
||
if (nextchar >= 0)
|
||
c = nextchar, nextchar = -1;
|
||
else
|
||
c = tee_getc (finput);
|
||
|
||
/* 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 '\r':
|
||
case '\v':
|
||
case '\b':
|
||
c = tee_getc (finput);
|
||
break;
|
||
|
||
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:
|
||
end_of_file = 1;
|
||
token_buffer[0] = 0;
|
||
value = ENDFILE;
|
||
break;
|
||
|
||
case '$':
|
||
if (dollars_in_ident)
|
||
goto letter;
|
||
return '$';
|
||
|
||
case 'L':
|
||
/* Capital L may start a wide-string or wide-character constant. */
|
||
{
|
||
register int c = tee_getc (finput);
|
||
if (c == '\'')
|
||
{
|
||
wide_flag = 1;
|
||
goto char_constant;
|
||
}
|
||
if (c == '"')
|
||
{
|
||
wide_flag = 1;
|
||
goto string_constant;
|
||
}
|
||
tee_ungetc (c, finput);
|
||
}
|
||
|
||
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:
|
||
p = token_buffer;
|
||
while (isalnum (c) || c == '_' || c == '$')
|
||
{
|
||
if (p >= token_buffer + maxtoken)
|
||
p = extend_token_buffer (p);
|
||
if (c == '$' && ! dollars_in_ident)
|
||
break;
|
||
|
||
*p++ = c;
|
||
c = tee_getc (finput);
|
||
}
|
||
|
||
*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)
|
||
yylval.ttype = ridpointers[(int) ptr->rid];
|
||
if ((! flag_no_asm
|
||
/* -fno-asm means don't recognize the non-ANSI keywords. */
|
||
|| ((int) ptr->token != ASM
|
||
&& (int) ptr->token != TYPEOF
|
||
&& ptr->rid != RID_INLINE)
|
||
/* Recognize __asm and __inline despite -fno-asm. */
|
||
|| token_buffer[0] == '_')
|
||
/* -ftraditional means don't recognize nontraditional keywords
|
||
typeof, const, volatile, signed or inline. */
|
||
&& (! flag_traditional
|
||
|| ((int) ptr->token != TYPE_QUAL
|
||
&& (int) ptr->token != TYPEOF
|
||
&& ptr->rid != RID_SIGNED
|
||
&& ptr->rid != RID_INLINE)
|
||
/* Recognize __inline, etc. despite -ftraditional. */
|
||
|| token_buffer[0] == '_'))
|
||
value = (int) ptr->token;
|
||
}
|
||
}
|
||
|
||
/* If we did not find a keyword, look for an identifier
|
||
(or a typename). */
|
||
|
||
if (value == IDENTIFIER)
|
||
{
|
||
yylval.ttype = get_identifier (token_buffer);
|
||
lastiddecl = lookup_name (yylval.ttype);
|
||
|
||
if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
|
||
value = TYPENAME;
|
||
}
|
||
|
||
break;
|
||
|
||
case '0': case '1': case '2': case '3': case '4':
|
||
case '5': case '6': case '7': case '8': case '9':
|
||
case '.':
|
||
{
|
||
int base = 10;
|
||
int count = 0;
|
||
int largest_digit = 0;
|
||
int numdigits = 0;
|
||
/* for multi-precision arithmetic,
|
||
we store only 8 live bits in each short,
|
||
giving us 64 bits of reliable precision */
|
||
short shorts[8];
|
||
int overflow = 0;
|
||
|
||
enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
|
||
= NOT_FLOAT;
|
||
|
||
for (count = 0; count < 8; count++)
|
||
shorts[count] = 0;
|
||
|
||
p = token_buffer;
|
||
*p++ = c;
|
||
|
||
if (c == '0')
|
||
{
|
||
*p++ = (c = tee_getc (finput));
|
||
if ((c == 'x') || (c == 'X'))
|
||
{
|
||
base = 16;
|
||
*p++ = (c = tee_getc (finput));
|
||
}
|
||
else
|
||
{
|
||
base = 8;
|
||
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 = tee_getc (finput);
|
||
/* 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 = tee_getc (finput);
|
||
if (c == '.')
|
||
{
|
||
*p++ = c;
|
||
*p = 0;
|
||
return ELLIPSIS;
|
||
}
|
||
error ("parse error at `..'");
|
||
}
|
||
tee_ungetc (c, finput);
|
||
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&~040) == '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 < 8; count++)
|
||
{
|
||
shorts[count] *= base;
|
||
if (count)
|
||
{
|
||
shorts[count] += (shorts[count-1] >> 8);
|
||
shorts[count-1] &= (1<<8)-1;
|
||
}
|
||
else shorts[0] += c;
|
||
}
|
||
|
||
if (shorts[7] >= 1<<8
|
||
|| shorts[7] < - (1 << 8))
|
||
overflow = TRUE;
|
||
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = (c = tee_getc (finput));
|
||
}
|
||
}
|
||
|
||
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;
|
||
REAL_VALUE_TYPE value;
|
||
|
||
/* 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 = tee_getc (finput);
|
||
if ((c == '+') || (c == '-'))
|
||
{
|
||
*p++ = c;
|
||
c = tee_getc (finput);
|
||
}
|
||
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 = tee_getc (finput);
|
||
}
|
||
}
|
||
|
||
*p = 0;
|
||
errno = 0;
|
||
value = REAL_VALUE_ATOF (token_buffer);
|
||
#ifdef ERANGE
|
||
if (errno == ERANGE && !flag_traditional)
|
||
{
|
||
char *p1 = token_buffer;
|
||
/* Check for "0.0" and variants;
|
||
Sunos 4 spuriously returns ERANGE for them. */
|
||
while (*p1 == '0') p1++;
|
||
if (*p1 == '.')
|
||
{
|
||
p1++;
|
||
while (*p1 == '0') p1++;
|
||
}
|
||
if (*p1 == 'e' || *p1 == 'E')
|
||
{
|
||
/* with significand==0, ignore the exponent */
|
||
p1++;
|
||
while (*p1 != 0) p1++;
|
||
}
|
||
if (*p1 != 0)
|
||
warning ("floating point number exceeds range of `double'");
|
||
}
|
||
#endif
|
||
|
||
/* Read the suffixes to choose a data type. */
|
||
while (1)
|
||
{
|
||
if (c == 'f' || c == 'F')
|
||
{
|
||
float floater;
|
||
if (f_seen)
|
||
error ("two `f's in floating constant");
|
||
f_seen = 1;
|
||
type = float_type_node;
|
||
floater = value;
|
||
value = floater;
|
||
}
|
||
else if (c == 'l' || c == 'L')
|
||
{
|
||
if (l_seen)
|
||
error ("two `l's in floating constant");
|
||
l_seen = 1;
|
||
type = long_double_type_node;
|
||
}
|
||
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 = tee_getc (finput);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = tee_getc (finput);
|
||
}
|
||
|
||
/* Create a node with determined type and value. */
|
||
yylval.ttype = build_real (type, value);
|
||
|
||
tee_ungetc (c, finput);
|
||
*p = 0;
|
||
}
|
||
else
|
||
{
|
||
tree type;
|
||
int spec_unsigned = 0;
|
||
int spec_long = 0;
|
||
int spec_long_long = 0;
|
||
|
||
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)
|
||
warning ("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 = tee_getc (finput);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
if (p >= token_buffer + maxtoken - 3)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
c = tee_getc (finput);
|
||
}
|
||
|
||
tee_ungetc (c, finput);
|
||
|
||
if ((overflow || shorts[7] || shorts[6] || shorts[5] || shorts[4])
|
||
&& !spec_long_long)
|
||
warning ("integer constant out of range");
|
||
|
||
/* If it won't fit in a signed long long, make it unsigned.
|
||
We can't distinguish based on the tree node because
|
||
any integer constant fits any long long type. */
|
||
if (shorts[7] >= (1<<8))
|
||
spec_unsigned = 1;
|
||
|
||
/* This is simplified by the fact that our constant
|
||
is always positive. */
|
||
yylval.ttype
|
||
= (build_int_2
|
||
((shorts[3]<<24) + (shorts[2]<<16) + (shorts[1]<<8) + shorts[0],
|
||
(spec_long_long
|
||
? (shorts[7]<<24) + (shorts[6]<<16) + (shorts[5]<<8) + shorts[4]
|
||
: 0)));
|
||
|
||
if (!spec_long && !spec_unsigned
|
||
&& int_fits_type_p (yylval.ttype, integer_type_node))
|
||
type = integer_type_node;
|
||
|
||
else if (!spec_long && base != 10
|
||
&& int_fits_type_p (yylval.ttype, unsigned_type_node))
|
||
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))
|
||
type = long_unsigned_type_node;
|
||
|
||
else if (! spec_unsigned
|
||
&& 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))
|
||
type = long_long_unsigned_type_node;
|
||
|
||
else
|
||
{
|
||
type = long_long_integer_type_node;
|
||
warning ("integer constant out of range");
|
||
}
|
||
|
||
TREE_TYPE (yylval.ttype) = type;
|
||
}
|
||
|
||
value = CONSTANT; break;
|
||
}
|
||
|
||
case '\'':
|
||
char_constant:
|
||
{
|
||
register int result = 0;
|
||
register num_chars = 0;
|
||
int width = TYPE_PRECISION (char_type_node);
|
||
int max_chars;
|
||
|
||
if (wide_flag) width = TYPE_PRECISION (integer_type_node);
|
||
|
||
max_chars = TYPE_PRECISION (integer_type_node) / width;
|
||
|
||
while (1)
|
||
{
|
||
tryagain:
|
||
|
||
c = tee_getc (finput);
|
||
|
||
if (c == '\'' || c == EOF)
|
||
break;
|
||
|
||
if (c == '\\')
|
||
{
|
||
c = readescape ();
|
||
if (c < 0)
|
||
goto tryagain;
|
||
if (width < HOST_BITS_PER_INT
|
||
&& (unsigned) c >= (1 << width))
|
||
warning ("escape sequence out of range for character");
|
||
}
|
||
else if (c == '\n')
|
||
{
|
||
if (pedantic)
|
||
warning ("ANSI C forbids newline in character constant");
|
||
lineno++;
|
||
}
|
||
|
||
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 (TREE_UNSIGNED (char_type_node)
|
||
|| ((result >> (num_bits - 1)) & 1) == 0)
|
||
yylval.ttype
|
||
= build_int_2 (result & ((unsigned) ~0
|
||
>> (HOST_BITS_PER_INT - num_bits)),
|
||
0);
|
||
else
|
||
yylval.ttype
|
||
= build_int_2 (result | ~((unsigned) ~0
|
||
>> (HOST_BITS_PER_INT - num_bits)),
|
||
-1);
|
||
}
|
||
else
|
||
yylval.ttype = build_int_2 (result, 0);
|
||
|
||
TREE_TYPE (yylval.ttype) = integer_type_node;
|
||
value = CONSTANT; break;
|
||
}
|
||
|
||
case '"':
|
||
string_constant:
|
||
{
|
||
int *widep;
|
||
|
||
c = tee_getc (finput);
|
||
p = token_buffer + 1;
|
||
|
||
if (wide_flag)
|
||
widep = wide_buffer;
|
||
|
||
while (c != '"' && c >= 0)
|
||
{
|
||
if (c == '\\')
|
||
{
|
||
c = readescape ();
|
||
if (c < 0)
|
||
goto skipnewline;
|
||
if (!wide_flag && c >= (1 << TYPE_PRECISION (char_type_node)))
|
||
warning ("escape sequence out of range for character");
|
||
}
|
||
else if (c == '\n')
|
||
{
|
||
if (pedantic)
|
||
warning ("ANSI C forbids newline in string constant");
|
||
lineno++;
|
||
}
|
||
|
||
/* Store the char in C into the appropriate buffer. */
|
||
|
||
if (wide_flag)
|
||
{
|
||
if (widep == wide_buffer + max_wide)
|
||
{
|
||
int n = widep - wide_buffer;
|
||
max_wide *= 2;
|
||
wide_buffer = (int *) xrealloc (wide_buffer, max_wide + 1);
|
||
widep = wide_buffer + n;
|
||
}
|
||
*widep++ = c;
|
||
}
|
||
else
|
||
{
|
||
if (p == token_buffer + maxtoken)
|
||
p = extend_token_buffer (p);
|
||
*p++ = c;
|
||
}
|
||
|
||
skipnewline:
|
||
c = tee_getc (finput);
|
||
}
|
||
|
||
/* We have read the entire constant.
|
||
Construct a STRING_CST for the result. */
|
||
|
||
if (wide_flag)
|
||
{
|
||
/* If this is a L"..." wide-string, make a vector
|
||
of the ints in wide_buffer. */
|
||
*widep = 0;
|
||
/* We have not implemented the case where `int'
|
||
on the target and on the execution machine differ in size. */
|
||
if (TYPE_PRECISION (integer_type_node)
|
||
!= sizeof (int) * BITS_PER_UNIT)
|
||
abort ();
|
||
yylval.ttype = build_string ((widep - wide_buffer) * sizeof (int),
|
||
wide_buffer);
|
||
TREE_TYPE (yylval.ttype) = int_array_type_node;
|
||
}
|
||
else
|
||
{
|
||
*p = 0;
|
||
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 = tee_getc (finput);
|
||
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 == '>'))
|
||
{ value = POINTSAT; goto done; }
|
||
tee_ungetc (c1, finput);
|
||
token_buffer[1] = 0;
|
||
|
||
if ((c == '<') || (c == '>'))
|
||
value = ARITHCOMPARE;
|
||
else value = c;
|
||
goto done;
|
||
}
|
||
|
||
case 0:
|
||
/* Don't make yyparse think this is eof. */
|
||
value = 1;
|
||
break;
|
||
|
||
default:
|
||
value = c;
|
||
}
|
||
|
||
done:
|
||
/* yylloc.last_line = lineno; */
|
||
|
||
return value;
|
||
}
|