728 lines
14 KiB
Plaintext
728 lines
14 KiB
Plaintext
/*
|
|
* (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
|
|
* See the copyright notice in the ACK home directory, in the file "Copyright".
|
|
*/
|
|
/* $Header$ */
|
|
/* DECLARATION SYNTAX PARSER */
|
|
|
|
{
|
|
#include "lint.h"
|
|
#include <alloc.h>
|
|
#include "nobitfield.h"
|
|
#include "debug.h"
|
|
#include <flt_arith.h>
|
|
#include "arith.h"
|
|
#include "LLlex.h"
|
|
#include "label.h"
|
|
#include "code.h"
|
|
#include "idf.h"
|
|
#include "type.h"
|
|
#include "proto.h"
|
|
#include "struct.h"
|
|
#include "field.h"
|
|
#include "decspecs.h"
|
|
#include "def.h"
|
|
#include "declar.h"
|
|
#include "label.h"
|
|
#include "expr.h"
|
|
#include "sizes.h"
|
|
#include "level.h"
|
|
#ifdef LINT
|
|
#include "l_lint.h"
|
|
#include "l_state.h"
|
|
#endif LINT
|
|
}
|
|
|
|
/* 3.5 */
|
|
declaration
|
|
{struct decspecs Ds;}
|
|
:
|
|
{Ds = null_decspecs;}
|
|
decl_specifiers(&Ds)
|
|
init_declarator_list(&Ds)?
|
|
';'
|
|
;
|
|
|
|
/* A `decl_specifiers' describes a sequence of a storage_class_specifier,
|
|
an unsigned_specifier, a size_specifier and a simple type_specifier,
|
|
which may occur in arbitrary order and each of which may be absent;
|
|
at least one of them must be present, however, since the totally
|
|
empty case has already be dealt with in `external_definition'.
|
|
This means that something like:
|
|
unsigned extern int short xx;
|
|
is perfectly legal C.
|
|
|
|
On top of that, multiple occurrences of storage_class_specifiers,
|
|
unsigned_specifiers and size_specifiers are errors, but a second
|
|
type_specifier should end the decl_specifiers and be treated as
|
|
the name to be declared.
|
|
Such a language is not easily expressed in a grammar; enumeration
|
|
of the permutations is unattractive. We solve the problem by
|
|
having a regular grammar for the "soft" items, handling the single
|
|
occurrence of the type_specifier in the grammar (we have no choice),
|
|
collecting all data in a `struct decspecs' and turning that data
|
|
structure into what we want.
|
|
|
|
The existence of declarations like
|
|
short typedef yepp;
|
|
makes all hope of writing a specific grammar for typedefs illusory.
|
|
*/
|
|
|
|
decl_specifiers /* non-empty */ (register struct decspecs *ds;)
|
|
/* Reads a non-empty decl_specifiers and fills the struct
|
|
decspecs *ds.
|
|
*/
|
|
:
|
|
[
|
|
other_specifier(ds)+
|
|
[%if (DOT != IDENTIFIER || AHEAD == IDENTIFIER)
|
|
/* the thin ice in R.M. 11.1 */
|
|
single_type_specifier(ds) other_specifier(ds)*
|
|
|
|
|
empty
|
|
]
|
|
|
|
|
single_type_specifier(ds) other_specifier(ds)*
|
|
]
|
|
{do_decspecs(ds);}
|
|
;
|
|
|
|
/* 3.5.1 & 3.5.2 (partially) & 3.5.3 (partially) */
|
|
other_specifier(register struct decspecs *ds;)
|
|
:
|
|
[ AUTO | STATIC | EXTERN | TYPEDEF | REGISTER ]
|
|
{ if (ds->ds_sc_given)
|
|
error("repeated storage class specifier");
|
|
ds->ds_sc_given = 1;
|
|
ds->ds_sc = DOT;
|
|
}
|
|
|
|
|
[ SHORT | LONG ]
|
|
{ if (ds->ds_size)
|
|
error("repeated size specifier");
|
|
ds->ds_size = DOT;
|
|
}
|
|
|
|
|
[ SIGNED | UNSIGNED ]
|
|
{ if (ds->ds_unsigned != 0)
|
|
error("repeated sign specifier");
|
|
ds->ds_unsigned = DOT;
|
|
}
|
|
|
|
|
/* This qualifier applies to the top type.
|
|
E.g. const float * is a pointer to const float.
|
|
*/
|
|
[ VOLATILE | CONST ]
|
|
{ if (DOT == VOLATILE) {
|
|
if (ds->ds_typequal & TQ_VOLATILE)
|
|
error("repeated type qualifier");
|
|
ds->ds_typequal |= TQ_VOLATILE;
|
|
}
|
|
if (DOT == CONST) {
|
|
if (ds->ds_typequal & TQ_CONST)
|
|
error("repeated type qualifier");
|
|
ds->ds_typequal |= TQ_CONST;
|
|
}
|
|
}
|
|
;
|
|
|
|
/* 3.5.2 */
|
|
type_specifier(struct type **tpp;)
|
|
/* Used in struct/union declarations and in casts; only the
|
|
type is relevant.
|
|
*/
|
|
{struct decspecs Ds; Ds = null_decspecs;}
|
|
:
|
|
decl_specifiers(&Ds)
|
|
{
|
|
if (Ds.ds_sc_given)
|
|
error("storage class ignored");
|
|
if (Ds.ds_sc == REGISTER)
|
|
error("register ignored");
|
|
}
|
|
{*tpp = Ds.ds_type;}
|
|
;
|
|
|
|
single_type_specifier(register struct decspecs *ds;):
|
|
%default TYPE_IDENTIFIER /* this includes INT, CHAR, etc. */
|
|
{idf2type(dot.tk_idf, &ds->ds_type);}
|
|
|
|
|
IDENTIFIER
|
|
{
|
|
error("%s is not a type identifier", dot.tk_idf->id_text);
|
|
ds->ds_type = error_type;
|
|
if (dot.tk_idf->id_def) {
|
|
dot.tk_idf->id_def->df_type = error_type;
|
|
dot.tk_idf->id_def->df_sc = TYPEDEF;
|
|
}
|
|
}
|
|
|
|
|
struct_or_union_specifier(&ds->ds_type)
|
|
|
|
|
enum_specifier(&ds->ds_type)
|
|
;
|
|
|
|
/* 3.5 */
|
|
init_declarator_list(struct decspecs *ds;):
|
|
init_declarator(ds)
|
|
[ ',' init_declarator(ds) ]*
|
|
;
|
|
|
|
init_declarator(register struct decspecs *ds;)
|
|
{
|
|
struct declarator Dc;
|
|
}
|
|
:
|
|
{
|
|
Dc = null_declarator;
|
|
}
|
|
[
|
|
declarator(&Dc)
|
|
{
|
|
reject_params(&Dc);
|
|
def_proto(&Dc);
|
|
declare_idf(ds, &Dc, level);
|
|
#ifdef LINT
|
|
lint_declare_idf(Dc.dc_idf, ds->ds_sc);
|
|
#endif LINT
|
|
}
|
|
[
|
|
initializer(Dc.dc_idf, ds->ds_sc)
|
|
|
|
|
{ code_declaration(Dc.dc_idf, (struct expr *) 0, level, ds->ds_sc); }
|
|
]
|
|
]
|
|
{
|
|
#ifdef LINT
|
|
add_auto(Dc.dc_idf);
|
|
#endif LINT
|
|
remove_declarator(&Dc);
|
|
}
|
|
;
|
|
|
|
/* 3.5.7: initializer */
|
|
initializer(struct idf *idf; int sc;)
|
|
{
|
|
struct expr *expr = (struct expr *) 0;
|
|
int fund = idf->id_def->df_type->tp_fund;
|
|
int autoagg = (level >= L_LOCAL
|
|
&& sc != STATIC
|
|
&& ( fund == STRUCT
|
|
|| fund == UNION
|
|
|| fund == ARRAY));
|
|
int globalflag = level == L_GLOBAL
|
|
|| (level >= L_LOCAL && sc == STATIC);
|
|
}
|
|
:
|
|
{ if (idf->id_def->df_type->tp_fund == FUNCTION) {
|
|
error("illegal initialization of function");
|
|
idf->id_def->df_type->tp_fund = ERRONEOUS;
|
|
}
|
|
if (level == L_FORMAL2)
|
|
warning("illegal initialization of formal parameter (ignored)");
|
|
}
|
|
'='
|
|
{
|
|
#ifdef LINT
|
|
lint_statement();
|
|
#endif LINT
|
|
if (globalflag) {
|
|
struct expr ex;
|
|
code_declaration(idf, &ex, level, sc);
|
|
}
|
|
else if (autoagg)
|
|
loc_init((struct expr *) 0, idf);
|
|
}
|
|
initial_value((globalflag || autoagg) ?
|
|
&(idf->id_def->df_type)
|
|
: (struct type **)0,
|
|
&expr)
|
|
{ if (! globalflag) {
|
|
if (idf->id_def->df_type->tp_fund == FUNCTION) {
|
|
free_expression(expr);
|
|
expr = 0;
|
|
}
|
|
#ifdef DEBUG
|
|
print_expr("initializer-expression", expr);
|
|
#endif DEBUG
|
|
#ifdef LINT
|
|
change_state(idf, SET);
|
|
#endif LINT
|
|
if (autoagg)
|
|
loc_init((struct expr *) 0, idf);
|
|
else code_declaration(idf, expr, level, sc);
|
|
}
|
|
init_idf(idf);
|
|
}
|
|
;
|
|
|
|
/*
|
|
Functions yielding pointers to functions must be declared as, e.g.,
|
|
int (*hehe(par1, par2))() char *par1, *par2; {}
|
|
Since the function heading is read as a normal declarator,
|
|
we just include the (formal) parameter list in the declarator
|
|
description list dc.
|
|
*/
|
|
/* 3.5.4 */
|
|
declarator(register struct declarator *dc;)
|
|
{ struct formal *fm = NO_PARAMS;
|
|
struct proto *pl = NO_PROTO;
|
|
arith count;
|
|
int qual;
|
|
}
|
|
:
|
|
primary_declarator(dc)
|
|
[/*%while(1)*/
|
|
'('
|
|
[ %if (DOT != IDENTIFIER && DOT != ')')
|
|
parameter_type_list(&pl)
|
|
|
|
|
formal_list(&fm)
|
|
|
|
|
empty
|
|
]
|
|
')'
|
|
{ add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
|
|
fm = NO_PARAMS;
|
|
}
|
|
|
|
|
arrayer(&count)
|
|
{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
|
|
]*
|
|
|
|
|
pointer(&qual) declarator(dc)
|
|
{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
|
|
;
|
|
|
|
primary_declarator(register struct declarator *dc;) :
|
|
identifier(&dc->dc_idf)
|
|
|
|
|
'(' declarator(dc) ')'
|
|
;
|
|
|
|
arrayer(arith *sizep;)
|
|
{ struct expr *expr; }
|
|
:
|
|
'['
|
|
[
|
|
constant_expression(&expr)
|
|
{
|
|
check_array_subscript(expr);
|
|
*sizep = expr->VL_VALUE;
|
|
free_expression(expr);
|
|
}
|
|
|
|
|
empty
|
|
{ *sizep = (arith)-1; }
|
|
]
|
|
']'
|
|
;
|
|
|
|
formal_list (struct formal **fmp;)
|
|
:
|
|
formal(fmp) [ %persistent ',' formal(fmp) ]*
|
|
;
|
|
|
|
formal(struct formal **fmp;)
|
|
{struct idf *idf; }
|
|
:
|
|
identifier(&idf)
|
|
{
|
|
register struct formal *new = new_formal();
|
|
|
|
new->fm_idf = idf;
|
|
new->next = *fmp;
|
|
*fmp = new;
|
|
}
|
|
;
|
|
|
|
/* Change 2 */
|
|
enum_specifier(register struct type **tpp;)
|
|
{
|
|
struct idf *idf;
|
|
arith l = (arith)0;
|
|
}
|
|
:
|
|
ENUM
|
|
[
|
|
{declare_struct(ENUM, (struct idf *) 0, tpp);}
|
|
enumerator_pack(*tpp, &l)
|
|
|
|
|
identifier(&idf)
|
|
[
|
|
{declare_struct(ENUM, idf, tpp);}
|
|
enumerator_pack(*tpp, &l)
|
|
|
|
|
{apply_struct(ENUM, idf, tpp);}
|
|
empty
|
|
]
|
|
]
|
|
;
|
|
|
|
enumerator_pack(register struct type *tp; arith *lp;) :
|
|
'{'
|
|
enumerator(tp, lp)
|
|
[%while (AHEAD != '}')
|
|
','
|
|
enumerator(tp, lp)
|
|
]*
|
|
[
|
|
',' {warning("unexpected trailing comma in enumerator pack");}
|
|
]?
|
|
'}'
|
|
{tp->tp_size = int_size;}
|
|
/* fancy implementations that put small enums in 1 byte
|
|
or so should start here.
|
|
*/
|
|
;
|
|
|
|
enumerator(struct type *tp; arith *lp;)
|
|
{
|
|
struct idf *idf;
|
|
struct expr *expr;
|
|
}
|
|
:
|
|
identifier(&idf)
|
|
[
|
|
'='
|
|
constant_expression(&expr)
|
|
{
|
|
*lp = expr->VL_VALUE;
|
|
free_expression(expr);
|
|
}
|
|
]?
|
|
{declare_enum(tp, idf, (*lp)++);}
|
|
;
|
|
|
|
/* 8.5 */
|
|
struct_or_union_specifier(register struct type **tpp;)
|
|
{
|
|
int fund;
|
|
struct idf *idfX;
|
|
register struct idf *idf;
|
|
}
|
|
:
|
|
[ STRUCT | UNION ]
|
|
{fund = DOT;}
|
|
[
|
|
{
|
|
declare_struct(fund, (struct idf *)0, tpp);
|
|
}
|
|
struct_declaration_pack(*tpp)
|
|
|
|
|
identifier(&idfX) { idf = idfX; }
|
|
[
|
|
{
|
|
declare_struct(fund, idf, tpp);
|
|
(idf->id_struct->tg_busy)++;
|
|
}
|
|
struct_declaration_pack(*tpp)
|
|
{
|
|
(idf->id_struct->tg_busy)--;
|
|
}
|
|
|
|
|
{
|
|
/* a ';' means an empty declaration (probably)
|
|
* this means that we have to declare a new
|
|
* structure. (yegh)
|
|
*/
|
|
if (DOT == ';') declare_struct(fund, idf, tpp);
|
|
else apply_struct(fund, idf, tpp);
|
|
}
|
|
empty
|
|
]
|
|
]
|
|
;
|
|
|
|
struct_declaration_pack(register struct type *stp;)
|
|
{
|
|
struct sdef **sdefp = &stp->tp_sdef;
|
|
arith size = (arith)0;
|
|
}
|
|
:
|
|
/* The size is only filled in after the whole struct has
|
|
been read, to prevent recursive definitions.
|
|
*/
|
|
'{'
|
|
struct_declaration(stp, &sdefp, &size)+
|
|
'}'
|
|
{stp->tp_size = align(size, stp->tp_align);}
|
|
;
|
|
|
|
struct_declaration(struct type *stp; struct sdef ***sdefpp; arith *szp;)
|
|
{struct type *tp;}
|
|
:
|
|
type_specifier(&tp) struct_declarator_list(tp, stp, sdefpp, szp) ';'
|
|
;
|
|
|
|
struct_declarator_list(struct type *tp, *stp;
|
|
struct sdef ***sdefpp; arith *szp;)
|
|
:
|
|
struct_declarator(tp, stp, sdefpp, szp)
|
|
[ ',' struct_declarator(tp, stp, sdefpp, szp) ]*
|
|
;
|
|
|
|
struct_declarator(struct type *tp; struct type *stp;
|
|
struct sdef ***sdefpp; arith *szp;)
|
|
{
|
|
struct declarator Dc;
|
|
struct field *fd = 0;
|
|
}
|
|
:
|
|
{
|
|
Dc = null_declarator;
|
|
}
|
|
[
|
|
declarator(&Dc)
|
|
{reject_params(&Dc);}
|
|
bit_expression(&fd)?
|
|
|
|
|
{Dc.dc_idf = gen_idf();}
|
|
bit_expression(&fd)
|
|
]
|
|
{add_sel(stp, declare_type(tp, &Dc), Dc.dc_idf, sdefpp, szp, fd);}
|
|
{remove_declarator(&Dc);}
|
|
;
|
|
|
|
bit_expression(struct field **fd;)
|
|
{ struct expr *expr; }
|
|
:
|
|
{
|
|
*fd = new_field();
|
|
}
|
|
':'
|
|
constant_expression(&expr)
|
|
{
|
|
(*fd)->fd_width = expr->VL_VALUE;
|
|
free_expression(expr);
|
|
#ifdef NOBITFIELD
|
|
error("bitfields are not implemented");
|
|
#endif NOBITFIELD
|
|
}
|
|
;
|
|
|
|
/* 8.7 */
|
|
cast(struct type **tpp;)
|
|
{struct declarator Dc;}
|
|
:
|
|
{Dc = null_declarator;}
|
|
'('
|
|
type_specifier(tpp)
|
|
abstract_declarator(&Dc)
|
|
')'
|
|
{*tpp = declare_type(*tpp, &Dc);}
|
|
{remove_declarator(&Dc);}
|
|
;
|
|
|
|
/* This code is an abject copy of that of 'declarator', for lack of
|
|
a two-level grammar.
|
|
*/
|
|
abstract_declarator(register struct declarator *dc;)
|
|
{ struct proto *pl = NO_PROTO;
|
|
arith count;
|
|
int qual;
|
|
}
|
|
:
|
|
primary_abstract_declarator(dc)
|
|
[
|
|
'('
|
|
[
|
|
parameter_type_list(&pl)
|
|
|
|
|
empty
|
|
]
|
|
')'
|
|
{add_decl_unary(dc, FUNCTION, 0, (arith)0, NO_PARAMS, pl);}
|
|
|
|
|
arrayer(&count)
|
|
{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
|
|
]*
|
|
|
|
|
pointer(&qual) abstract_declarator(dc)
|
|
{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
|
|
;
|
|
|
|
%first first_of_parameter_type_list, parameter_type_list;
|
|
|
|
primary_abstract_declarator(struct declarator *dc;)
|
|
:
|
|
[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD))
|
|
empty
|
|
|
|
|
'(' abstract_declarator(dc) ')'
|
|
]
|
|
;
|
|
|
|
parameter_type_list(struct proto **plp;)
|
|
{ int save_level; }
|
|
:
|
|
{ if (level > L_PROTO) {
|
|
save_level = level;
|
|
level = L_PROTO;
|
|
} else level--;
|
|
}
|
|
parameter_decl_list(plp)
|
|
[
|
|
',' ELLIPSIS
|
|
{ register struct proto *new = new_proto();
|
|
|
|
new->next = *plp;
|
|
new->pl_flag = PL_ELLIPSIS;
|
|
*plp = new;
|
|
}
|
|
|
|
]?
|
|
{ check_for_void(*plp);
|
|
if (level == L_PROTO)
|
|
level = save_level;
|
|
else level++;
|
|
}
|
|
;
|
|
|
|
parameter_decl_list(struct proto **plp;)
|
|
:
|
|
parameter_decl(plp)
|
|
[ %while (AHEAD != ELLIPSIS)
|
|
%persistent
|
|
',' parameter_decl(plp)
|
|
]*
|
|
;
|
|
|
|
parameter_decl(struct proto **plp;)
|
|
{ register struct proto *new = new_proto();
|
|
struct declarator Dc;
|
|
struct decspecs Ds;
|
|
}
|
|
:
|
|
{ Dc = null_declarator;
|
|
Ds = null_decspecs;
|
|
}
|
|
decl_specifiers(&Ds)
|
|
parameter_declarator(&Dc)
|
|
{ add_proto(new, &Ds, &Dc, level);
|
|
new->next = *plp;
|
|
*plp = new;
|
|
}
|
|
;
|
|
|
|
/* This is weird. Due to the LR structure of the ANSI C grammar
|
|
we have to duplicate the actions of 'declarator' and
|
|
'abstract_declarator'. Calling these separate, as in
|
|
|
|
parameter_decl:
|
|
decl_specifiers
|
|
[
|
|
declarator
|
|
|
|
|
abstract_declarator
|
|
]
|
|
|
|
|
|
gives us a conflict on the terminals '(' and '*'. E.i. on
|
|
some input, it is impossible to decide which rule we take.
|
|
Combining the two declarators into one common declarator
|
|
is out of the question, since this results in an empty
|
|
string for the non-terminal 'declarator'.
|
|
So we combine the two only for the use of parameter_decl,
|
|
since this is the only place where they don't give
|
|
conflicts. However, this makes the grammar messy.
|
|
*/
|
|
parameter_declarator(register struct declarator *dc;)
|
|
{ struct formal *fm = NO_PARAMS;
|
|
struct proto *pl = NO_PROTO;
|
|
arith count;
|
|
int qual;
|
|
}
|
|
:
|
|
primary_parameter_declarator(dc)
|
|
[
|
|
'('
|
|
[ %if (DOT != IDENTIFIER)
|
|
parameter_type_list(&pl)
|
|
|
|
|
formal_list(&fm)
|
|
|
|
|
/* empty */
|
|
{
|
|
pl = new_proto();
|
|
pl->pl_type = void_type;
|
|
pl->pl_flag = PL_VOID;
|
|
}
|
|
]
|
|
')'
|
|
{ add_decl_unary(dc, FUNCTION, 0, (arith)0, fm, pl);
|
|
reject_params(dc);
|
|
}
|
|
|
|
|
arrayer(&count)
|
|
{add_decl_unary(dc, ARRAY, 0, count, NO_PARAMS, NO_PROTO);}
|
|
]*
|
|
|
|
|
pointer(&qual) parameter_declarator(dc)
|
|
{add_decl_unary(dc, POINTER, qual, (arith)0, NO_PARAMS, NO_PROTO);}
|
|
;
|
|
|
|
primary_parameter_declarator(register struct declarator *dc;)
|
|
:
|
|
[%if (AHEAD == ')' || first_of_parameter_type_list(AHEAD)
|
|
&& (AHEAD != IDENTIFIER))
|
|
empty
|
|
|
|
|
identifier(&dc->dc_idf)
|
|
|
|
|
'(' parameter_declarator(dc) ')'
|
|
]
|
|
;
|
|
|
|
pointer(int *qual;)
|
|
:
|
|
'*' type_qualifier_list(qual)
|
|
;
|
|
|
|
/* Type qualifiers may come in three flavours:
|
|
volatile, const, const volatile.
|
|
These all have different semantic properties:
|
|
|
|
volatile:
|
|
means that the object can be modified
|
|
without prior knowledge of the implementation.
|
|
|
|
const:
|
|
means that the object can not be modified; thus
|
|
it's illegal to use this as a l-value.
|
|
|
|
const volatile:
|
|
means that the object can be modified without
|
|
prior knowledge of the implementation, but may
|
|
not be used as a l-value.
|
|
*/
|
|
/* 3.5.4 */
|
|
type_qualifier_list(int *qual;)
|
|
:
|
|
[
|
|
[ VOLATILE | CONST ]
|
|
{ *qual = (DOT == VOLATILE) ? TQ_VOLATILE : TQ_CONST; }
|
|
[
|
|
[ VOLATILE | CONST ]
|
|
{ if (DOT == VOLATILE) {
|
|
if (*qual & TQ_VOLATILE)
|
|
error("repeated type qualifier");
|
|
*qual |= TQ_VOLATILE;
|
|
}
|
|
if (DOT == CONST) {
|
|
if (*qual & TQ_CONST)
|
|
error("repeated type qualifier");
|
|
*qual |= TQ_CONST;
|
|
}
|
|
}
|
|
|
|
]*
|
|
|
|
|
empty
|
|
{ *qual = 0; }
|
|
]
|
|
;
|
|
|
|
empty:
|
|
;
|