372 lines
6.4 KiB
Plaintext
372 lines
6.4 KiB
Plaintext
/* $Header$ */
|
|
/* EXPRESSION SYNTAX PARSER */
|
|
|
|
{
|
|
#include "arith.h"
|
|
#include "LLlex.h"
|
|
#include "type.h"
|
|
#include "idf.h"
|
|
#include "label.h"
|
|
#include "expr.h"
|
|
|
|
extern char options[];
|
|
extern struct expr *intexpr();
|
|
}
|
|
|
|
/* 7 */
|
|
initial_value(struct expr **expp;) :
|
|
[
|
|
assignment_expression(expp)
|
|
{
|
|
if ((*expp)->ex_type->tp_fund == ARRAY)
|
|
array2pointer(expp);
|
|
}
|
|
|
|
|
initial_value_pack(expp)
|
|
]
|
|
;
|
|
|
|
initial_value_pack(struct expr **expp;) :
|
|
'{'
|
|
initial_value_list(expp)
|
|
'}'
|
|
;
|
|
|
|
initial_value_list(struct expr **expp;)
|
|
{struct expr *e1;}
|
|
:
|
|
{*expp = NILEXPR;}
|
|
initial_value(&e1)
|
|
{init_expression(&expp, e1);}
|
|
[%while (AHEAD != '}') /* >>> conflict on ',' */
|
|
','
|
|
initial_value(&e1)
|
|
{init_expression(&expp, e1);}
|
|
]*
|
|
','? /* optional trailing comma */
|
|
;
|
|
|
|
|
|
/* 7.1 */
|
|
primary(struct expr **expp;) :
|
|
[
|
|
IDENTIFIER
|
|
{dot2expr(expp);}
|
|
|
|
|
constant(expp)
|
|
|
|
|
STRING
|
|
{dot2expr(expp);}
|
|
|
|
|
'(' expression(expp) ')'
|
|
{(*expp)->ex_flags |= EX_PARENS;}
|
|
]
|
|
;
|
|
|
|
secundary(struct expr **expp;) :
|
|
primary(expp)
|
|
[
|
|
index_pack(expp)
|
|
|
|
|
parameter_pack(expp)
|
|
|
|
|
selection(expp)
|
|
]*
|
|
;
|
|
|
|
index_pack(struct expr **expp;)
|
|
{struct expr *e1;}
|
|
:
|
|
'[' expression(&e1) ']'
|
|
{ch7bin(expp, '[', e1);}
|
|
;
|
|
|
|
parameter_pack(struct expr **expp;)
|
|
{struct expr *e1 = 0;}
|
|
:
|
|
'(' parameter_list(&e1)? ')'
|
|
{ch7bin(expp, '(', e1);}
|
|
;
|
|
|
|
selection(struct expr **expp;)
|
|
{int oper; struct idf *idf;}
|
|
:
|
|
[ '.' | ARROW ]
|
|
{oper = DOT;}
|
|
identifier(&idf)
|
|
{ch7sel(expp, oper, idf);}
|
|
;
|
|
|
|
parameter_list(struct expr **expp;)
|
|
{struct expr *e1 = 0;}
|
|
:
|
|
assignment_expression(expp)
|
|
{any2opnd(expp, PARCOMMA);}
|
|
[ ','
|
|
assignment_expression(&e1)
|
|
{any2opnd(&e1, PARCOMMA);}
|
|
{ch7bin(expp, PARCOMMA, e1);}
|
|
]*
|
|
;
|
|
|
|
/* 7.2 */
|
|
postfixed(struct expr **expp;)
|
|
{int oper;}
|
|
:
|
|
secundary(expp)
|
|
[
|
|
postop(&oper)
|
|
{ch7incr(expp, oper);}
|
|
|
|
|
empty
|
|
]
|
|
;
|
|
|
|
%first first_of_type_specifier, type_specifier;
|
|
|
|
unary(struct expr **expp;)
|
|
{struct type *tp; int oper;}
|
|
:
|
|
[%if (first_of_type_specifier(AHEAD))
|
|
cast(&tp) unary(expp)
|
|
{ ch7cast(expp, CAST, tp);
|
|
(*expp)->ex_flags |= EX_CAST;
|
|
}
|
|
|
|
|
postfixed(expp)
|
|
|
|
|
unop(&oper) unary(expp)
|
|
{ch7mon(oper, expp);}
|
|
|
|
|
size_of(expp)
|
|
]
|
|
;
|
|
|
|
size_of(struct expr **expp;)
|
|
{struct type *tp;}
|
|
:
|
|
SIZEOF
|
|
[%if (first_of_type_specifier(AHEAD))
|
|
cast(&tp)
|
|
{
|
|
*expp = intexpr(size_of_type(tp, "type"), INT);
|
|
(*expp)->ex_flags |= EX_SIZEOF;
|
|
}
|
|
|
|
|
unary(expp)
|
|
{ch7mon(SIZEOF, expp);}
|
|
]
|
|
;
|
|
|
|
/* 7.3-7.12 */
|
|
/* The set of operators in C is stratified in 15 levels, with level
|
|
N being treated in RM 7.N. In principle each operator is
|
|
assigned a rank, ranging from 1 to 15. Such an expression can
|
|
be parsed by a construct like:
|
|
binary_expression(int maxrank;)
|
|
{int oper;}
|
|
:
|
|
binary_expression(maxrank - 1)
|
|
[%if (rank_of(DOT) <= maxrank)
|
|
binop(&oper)
|
|
binary_expression(rank_of(oper)-1)
|
|
]?
|
|
;
|
|
except that some call of 'unary' is necessary, depending on the
|
|
grammar.
|
|
|
|
This simple view is marred by three complications:
|
|
1. Level 15 (comma operator) is not allowed in many
|
|
contexts and is different.
|
|
2. Level 13 (conditional operator) is a ternary operator,
|
|
which does not fit this scheme at all.
|
|
3. Level 14 (assignment operators) group right-to-left, as
|
|
opposed to 2-12, which group left-to-right (or are
|
|
immaterial).
|
|
4. The operators in level 14 start with operators in levels
|
|
2-13 (RM 7.14: The two parts of a compound assignment
|
|
operator are separate tokens.) This causes LL1 problems.
|
|
This forces us to have four rules:
|
|
binary_expression for level 2-12
|
|
conditional_expression for level 13
|
|
assignment_expression for level 14 and
|
|
expression for the most general expression
|
|
*/
|
|
|
|
binary_expression(int maxrank; struct expr **expp;)
|
|
{int oper; struct expr *e1;}
|
|
:
|
|
unary(expp)
|
|
[%while (rank_of(DOT) <= maxrank && AHEAD != '=')
|
|
/* '?', '=', and ',' are no binops, and the test
|
|
for AHEAD != '=' keeps the other assignment
|
|
operators out
|
|
*/
|
|
binop(&oper)
|
|
binary_expression(rank_of(oper)-1, &e1)
|
|
{
|
|
ch7bin(expp, oper, e1);
|
|
}
|
|
]*
|
|
;
|
|
|
|
/* 7.13 */
|
|
conditional_expression(struct expr **expp;)
|
|
/* There is some unfortunate disagreement about what is allowed
|
|
between the '?' and the ':' of a conditional_expression.
|
|
Although the Ritchie compiler does not even allow
|
|
conditional_expressions there, some other compilers (e.g., VAX)
|
|
accept a full assignment_expression there, and programs
|
|
(like, e.g., emacs) rely on it. So we have little choice.
|
|
*/
|
|
{struct expr *e1 = 0, *e2 = 0;}
|
|
:
|
|
/* allow all binary operators */
|
|
binary_expression(rank_of('?') - 1, expp)
|
|
[ '?'
|
|
expression(&e1)
|
|
{check_conditional(e1, '?', "between ? and :");}
|
|
':'
|
|
assignment_expression(&e2)
|
|
{check_conditional(e2, '=', "after :");}
|
|
{
|
|
ch7bin(&e1, ':', e2);
|
|
opnd2test(expp, '?');
|
|
ch7bin(expp, '?', e1);
|
|
}
|
|
]?
|
|
;
|
|
|
|
/* 7.14 */
|
|
assignment_expression(struct expr **expp;)
|
|
{
|
|
int oper;
|
|
struct expr *e1 = 0;
|
|
}
|
|
:
|
|
conditional_expression(expp)
|
|
[%prefer /* (rank_of(DOT) <= maxrank) for any asgnop */
|
|
asgnop(&oper)
|
|
assignment_expression(&e1)
|
|
{ch7asgn(expp, oper, e1);}
|
|
|
|
|
empty /* LLgen artefact ??? */
|
|
]
|
|
;
|
|
|
|
/* 7.15 */
|
|
expression(struct expr **expp;)
|
|
{struct expr *e1;}
|
|
:
|
|
assignment_expression(expp)
|
|
[ ','
|
|
assignment_expression(&e1)
|
|
{
|
|
ch7bin(expp, ',', e1);
|
|
}
|
|
]*
|
|
;
|
|
|
|
unop(int *oper;) :
|
|
['*' | '&' | '-' | '!' | '~' | PLUSPLUS | MINMIN]
|
|
{*oper = DOT;}
|
|
;
|
|
|
|
postop(int *oper;):
|
|
[
|
|
PLUSPLUS {*oper = POSTINCR;}
|
|
|
|
|
MINMIN {*oper = POSTDECR;}
|
|
]
|
|
;
|
|
|
|
multop:
|
|
'*' | '/' | '%'
|
|
;
|
|
|
|
addop:
|
|
'+' | '-'
|
|
;
|
|
|
|
shiftop:
|
|
LEFT | RIGHT
|
|
;
|
|
|
|
relop:
|
|
'<' | '>' | LESSEQ | GREATEREQ
|
|
;
|
|
|
|
eqop:
|
|
EQUAL | NOTEQUAL
|
|
;
|
|
|
|
arithop:
|
|
multop | addop | shiftop
|
|
|
|
|
'&' | '^' | '|'
|
|
;
|
|
|
|
binop(int *oper;) :
|
|
[ arithop | relop | eqop | AND | OR ]
|
|
{*oper = DOT;}
|
|
;
|
|
|
|
asgnop(int *oper;):
|
|
[
|
|
'=' {*oper = DOT;}
|
|
|
|
|
'+' '=' {*oper = PLUSAB;}
|
|
|
|
|
'-' '=' {*oper = MINAB;}
|
|
|
|
|
'*' '=' {*oper = TIMESAB;}
|
|
|
|
|
'/' '=' {*oper = DIVAB;}
|
|
|
|
|
'%' '=' {*oper = MODAB;}
|
|
|
|
|
LEFT '=' {*oper = LEFTAB;}
|
|
|
|
|
RIGHT '=' {*oper = RIGHTAB;}
|
|
|
|
|
'&' '=' {*oper = ANDAB;}
|
|
|
|
|
'^' '=' {*oper = XORAB;}
|
|
|
|
|
'|' '=' {*oper = ORAB;}
|
|
|
|
|
[ PLUSAB | MINAB | TIMESAB | DIVAB | MODAB |
|
|
LEFTAB | RIGHTAB | ANDAB | XORAB | ORAB ]
|
|
{
|
|
char *symbol2str();
|
|
|
|
warning("old-fashioned assignment operator, use %s",
|
|
symbol2str(DOT));
|
|
*oper = DOT;
|
|
}
|
|
]
|
|
;
|
|
|
|
constant(struct expr **expp;) :
|
|
[
|
|
INTEGER
|
|
|
|
|
FLOATING
|
|
] {dot2expr(expp);}
|
|
;
|
|
|
|
/* 15 */
|
|
constant_expression (struct expr **expp;) :
|
|
assignment_expression(expp)
|
|
{chk_cst_expr(expp);}
|
|
;
|
|
|
|
identifier(struct idf **idfp;) :
|
|
[
|
|
IDENTIFIER
|
|
|
|
|
TYPE_IDENTIFIER
|
|
]
|
|
{*idfp = dot.tk_idf;}
|
|
;
|