mirror of
https://github.com/golang/go
synced 2024-11-22 01:04:40 -07:00
baby step: const decls can refer to future
consts in the same factored block const ( X = Y; Y = 2; ) R=ken OCL=31782 CL=31782
This commit is contained in:
Russ Cox
parent
2ac1528e55
commit
db508ccbff
@ -618,7 +618,7 @@ bgen(Node *n, int true, Prog *to)
|
||||
nr = n->right;
|
||||
|
||||
if(n->type == T) {
|
||||
convlit(n, types[TBOOL]);
|
||||
convlit(&n, types[TBOOL]);
|
||||
if(n->type == T)
|
||||
goto ret;
|
||||
}
|
||||
|
||||
@ -53,24 +53,39 @@ truncfltlit(Mpflt *oldv, Type *t)
|
||||
* implicit conversion.
|
||||
*/
|
||||
void
|
||||
convlit(Node *n, Type *t)
|
||||
convlit(Node **np, Type *t)
|
||||
{
|
||||
convlit1(n, t, 0);
|
||||
return convlit1(np, t, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* convert n, if literal, to type t.
|
||||
* return a new node if necessary
|
||||
* (if n is a named constant, can't edit n->type directly).
|
||||
*/
|
||||
void
|
||||
convlit1(Node *n, Type *t, int explicit)
|
||||
convlit1(Node **np, Type *t, int explicit)
|
||||
{
|
||||
int et, ct;
|
||||
Node *n, *nn;
|
||||
|
||||
n = *np;
|
||||
if(n == N || t == T || n->type == T)
|
||||
return;
|
||||
et = t->etype;
|
||||
if(et == TIDEAL || et == TNIL)
|
||||
return;
|
||||
if(eqtype(t, n->type))
|
||||
return;
|
||||
|
||||
//dump("convlit1", n);
|
||||
if(n->op == OLITERAL) {
|
||||
nn = nod(OXXX, N, N);
|
||||
*nn = *n;
|
||||
n = nn;
|
||||
*np = n;
|
||||
}
|
||||
//dump("convlit2", n);
|
||||
|
||||
switch(n->op) {
|
||||
default:
|
||||
@ -79,7 +94,7 @@ convlit1(Node *n, Type *t, int explicit)
|
||||
break;
|
||||
case OLSH:
|
||||
case ORSH:
|
||||
convlit(n->left, t);
|
||||
convlit(&n->left, t);
|
||||
n->type = n->left->type;
|
||||
return;
|
||||
}
|
||||
@ -98,7 +113,7 @@ convlit1(Node *n, Type *t, int explicit)
|
||||
n->type = t;
|
||||
return;
|
||||
}
|
||||
defaultlit(n, T);
|
||||
defaultlit(np, T);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -172,8 +187,10 @@ convlit1(Node *n, Type *t, int explicit)
|
||||
return;
|
||||
|
||||
bad:
|
||||
if(n->type->etype == TIDEAL)
|
||||
defaultlit(n, T);
|
||||
if(n->type->etype == TIDEAL) {
|
||||
defaultlit(&n, T);
|
||||
*np = n;
|
||||
}
|
||||
yyerror("cannot convert %T constant to %T", n->type, t);
|
||||
n->diag = 1;
|
||||
return;
|
||||
@ -332,10 +349,14 @@ evconst(Node *n)
|
||||
switch(n->op) {
|
||||
default:
|
||||
// ideal const mixes with anything but otherwise must match.
|
||||
if(nl->type->etype != TIDEAL)
|
||||
defaultlit(nr, nl->type);
|
||||
if(nr->type->etype != TIDEAL)
|
||||
defaultlit(nl, nr->type);
|
||||
if(nl->type->etype != TIDEAL) {
|
||||
defaultlit(&nr, nl->type);
|
||||
n->right = nr;
|
||||
}
|
||||
if(nr->type->etype != TIDEAL) {
|
||||
defaultlit(&nl, nr->type);
|
||||
n->left = nl;
|
||||
}
|
||||
if(nl->type->etype != nr->type->etype)
|
||||
goto illegal;
|
||||
break;
|
||||
@ -344,7 +365,8 @@ evconst(Node *n)
|
||||
case ORSH:
|
||||
// right must be unsigned.
|
||||
// left can be ideal.
|
||||
defaultlit(nr, types[TUINT]);
|
||||
defaultlit(&nr, types[TUINT]);
|
||||
n->right = nr;
|
||||
if(nr->type && (issigned[nr->type->etype] || !isint[nr->type->etype]))
|
||||
goto illegal;
|
||||
break;
|
||||
@ -656,10 +678,12 @@ nodlit(Val v)
|
||||
}
|
||||
|
||||
void
|
||||
defaultlit(Node *n, Type *t)
|
||||
defaultlit(Node **np, Type *t)
|
||||
{
|
||||
int lno;
|
||||
Node *n, *nn;
|
||||
|
||||
n = *np;
|
||||
if(n == N)
|
||||
return;
|
||||
if(n->type == T || n->type->etype != TIDEAL)
|
||||
@ -667,10 +691,14 @@ defaultlit(Node *n, Type *t)
|
||||
|
||||
switch(n->op) {
|
||||
case OLITERAL:
|
||||
nn = nod(OXXX, N, N);
|
||||
*nn = *n;
|
||||
n = nn;
|
||||
*np = n;
|
||||
break;
|
||||
case OLSH:
|
||||
case ORSH:
|
||||
defaultlit(n->left, t);
|
||||
defaultlit(&n->left, t);
|
||||
n->type = n->left->type;
|
||||
return;
|
||||
}
|
||||
@ -715,25 +743,29 @@ defaultlit(Node *n, Type *t)
|
||||
* get the same type going out.
|
||||
*/
|
||||
void
|
||||
defaultlit2(Node *l, Node *r)
|
||||
defaultlit2(Node **lp, Node **rp)
|
||||
{
|
||||
Node *l, *r;
|
||||
|
||||
l = *lp;
|
||||
r = *rp;
|
||||
if(l->type == T || r->type == T)
|
||||
return;
|
||||
if(l->type->etype != TIDEAL && l->type->etype != TNIL) {
|
||||
convlit(r, l->type);
|
||||
convlit(rp, l->type);
|
||||
return;
|
||||
}
|
||||
if(r->type->etype != TIDEAL && r->type->etype != TNIL) {
|
||||
convlit(l, r->type);
|
||||
convlit(lp, r->type);
|
||||
return;
|
||||
}
|
||||
if(isconst(l, CTFLT) || isconst(r, CTFLT)) {
|
||||
convlit(l, types[TFLOAT]);
|
||||
convlit(r, types[TFLOAT]);
|
||||
convlit(lp, types[TFLOAT]);
|
||||
convlit(rp, types[TFLOAT]);
|
||||
return;
|
||||
}
|
||||
convlit(l, types[TINT]);
|
||||
convlit(r, types[TINT]);
|
||||
convlit(lp, types[TINT]);
|
||||
convlit(rp, types[TINT]);
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
@ -43,6 +43,7 @@ dodclvar(Node *n, Type *t, NodeList **init)
|
||||
*init = list(*init, nod(ODCL, n, N));
|
||||
}
|
||||
|
||||
// TODO(rsc): cut
|
||||
void
|
||||
dodclconst(Node *n, Node *e)
|
||||
{
|
||||
@ -513,8 +514,8 @@ funcbody(Node *n)
|
||||
dclcontext = PEXTERN;
|
||||
}
|
||||
|
||||
void
|
||||
funclit0(Type *t)
|
||||
Node*
|
||||
funclit0(Node *t)
|
||||
{
|
||||
Node *n;
|
||||
|
||||
@ -527,19 +528,23 @@ funclit0(Type *t)
|
||||
autodcl = dcl();
|
||||
autodcl->back = autodcl;
|
||||
|
||||
funcargs(t);
|
||||
walkexpr(t, Etype, &t->ninit);
|
||||
funcargs(t->type);
|
||||
return t;
|
||||
}
|
||||
|
||||
Node*
|
||||
funclit1(Type *type, NodeList *body)
|
||||
funclit1(Node *ntype, NodeList *body)
|
||||
{
|
||||
Node *func;
|
||||
Type *type;
|
||||
Node *a, *d, *f, *n, *clos;
|
||||
Type *ft, *t;
|
||||
Iter save;
|
||||
int narg, shift;
|
||||
NodeList *args, *l, *in, *out;
|
||||
|
||||
type = ntype->type;
|
||||
popdcl();
|
||||
func = funclit;
|
||||
funclit = func->outer;
|
||||
@ -957,7 +962,7 @@ addvar(Node *n, Type *t, int ctxt)
|
||||
Sym *s;
|
||||
int gen;
|
||||
|
||||
if(n==N || n->sym == S || n->op != ONAME || t == T)
|
||||
if(n==N || n->sym == S || (n->op != ONAME && n->op != ONONAME) || t == T)
|
||||
fatal("addvar: n=%N t=%T nil", n, t);
|
||||
|
||||
s = n->sym;
|
||||
@ -973,6 +978,7 @@ addvar(Node *n, Type *t, int ctxt)
|
||||
}
|
||||
|
||||
redeclare("variable", s);
|
||||
n->op = ONAME;
|
||||
s->vargen = gen;
|
||||
s->def = n;
|
||||
s->offset = 0;
|
||||
@ -1049,6 +1055,7 @@ addtyp(Type *n, int ctxt)
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(rsc): cut
|
||||
void
|
||||
addconst(Node *n, Node *e, int ctxt)
|
||||
{
|
||||
@ -1142,6 +1149,29 @@ newname(Sym *s)
|
||||
return n;
|
||||
}
|
||||
|
||||
Node*
|
||||
dclname(Sym *s)
|
||||
{
|
||||
Node *n;
|
||||
|
||||
// top-level name: might already have been
|
||||
// referred to, in which case s->def is already
|
||||
// set to an ONONAME.
|
||||
if(dclcontext == PEXTERN && s->block == 0) {
|
||||
// toss predefined name like "close"
|
||||
// TODO(rsc): put close in at the end.
|
||||
if(s->def != N && s->def->etype)
|
||||
s->def = N;
|
||||
if(s->def == N)
|
||||
oldname(s);
|
||||
return s->def;
|
||||
}
|
||||
|
||||
n = newname(s);
|
||||
n->op = ONONAME; // caller will correct it
|
||||
return n;
|
||||
}
|
||||
|
||||
Node*
|
||||
typenod(Type *t)
|
||||
{
|
||||
@ -1168,19 +1198,11 @@ oldname(Sym *s)
|
||||
|
||||
n = s->def;
|
||||
if(n == N) {
|
||||
n = nod(ONONAME, N, N);
|
||||
n->sym = s;
|
||||
n->type = T;
|
||||
n->addable = 1;
|
||||
n->ullman = 1;
|
||||
}
|
||||
if(n->op == OLITERAL) {
|
||||
c = nod(OLITERAL, N, N);
|
||||
c->sym = s;
|
||||
c->val = n->val;
|
||||
c->type = n->type;
|
||||
c->iota = n->iota;
|
||||
return c;
|
||||
// maybe a top-level name will come along
|
||||
// to give this a definition later.
|
||||
n = newname(s);
|
||||
n->op = ONONAME;
|
||||
s->def = n;
|
||||
}
|
||||
if(n->funcdepth > 0 && n->funcdepth != funcdepth && n->op == ONAME) {
|
||||
// inner func is referring to var
|
||||
@ -1648,7 +1670,7 @@ variter(NodeList *vl, Type *t, NodeList *el)
|
||||
tv = t;
|
||||
if(t == T) {
|
||||
gettype(e, &r);
|
||||
defaultlit(e, T);
|
||||
defaultlit(&e, T);
|
||||
tv = e->type;
|
||||
}
|
||||
dodclvar(v, tv, &r);
|
||||
@ -1664,14 +1686,16 @@ variter(NodeList *vl, Type *t, NodeList *el)
|
||||
* declare constants from grammar
|
||||
* new_name_list [[type] = expr_list]
|
||||
*/
|
||||
void
|
||||
constiter(NodeList *vl, Type *t, NodeList *cl)
|
||||
NodeList*
|
||||
constiter(NodeList *vl, Node *t, NodeList *cl)
|
||||
{
|
||||
Node *v, *c;
|
||||
NodeList *init;
|
||||
NodeList *vv;
|
||||
Sym *s;
|
||||
|
||||
vv = vl;
|
||||
if(cl == nil) {
|
||||
if(t != T)
|
||||
if(t != N)
|
||||
yyerror("constdcl cannot have type without expr");
|
||||
cl = lastconst;
|
||||
t = lasttype;
|
||||
@ -1689,27 +1713,22 @@ constiter(NodeList *vl, Type *t, NodeList *cl)
|
||||
c = cl->n;
|
||||
cl = cl->next;
|
||||
|
||||
init = nil;
|
||||
gettype(c, &init);
|
||||
if(init != nil) {
|
||||
// the expression had extra code to run.
|
||||
// dodclconst is going to print an error
|
||||
// because the expression isn't constant,
|
||||
// but out of paranoia, bump nerrors so
|
||||
// that compile cannot succeed accidentally
|
||||
nerrors++;
|
||||
}
|
||||
if(t != T)
|
||||
convlit(c, t);
|
||||
if(t == T)
|
||||
lasttype = c->type;
|
||||
|
||||
v = vl->n;
|
||||
dodclconst(v, c);
|
||||
s = v->sym;
|
||||
if(dclcontext != PEXTERN)
|
||||
pushdcl(s);
|
||||
redeclare("constant", s);
|
||||
s->def = v;
|
||||
|
||||
v->op = OLITERAL;
|
||||
v->ntype = t;
|
||||
v->defn = c;
|
||||
autoexport(s);
|
||||
}
|
||||
if(cl != nil)
|
||||
yyerror("extra expr in const dcl");
|
||||
iota += 1;
|
||||
return vv;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -324,7 +324,7 @@ importconst(Sym *s, Type *t, Node *n)
|
||||
if(!exportname(s->name) && !mypackage(s))
|
||||
return;
|
||||
importsym(s, OLITERAL);
|
||||
convlit(n, t);
|
||||
convlit(&n, t);
|
||||
if(s->def != N) {
|
||||
// TODO: check if already the same.
|
||||
return;
|
||||
|
||||
@ -227,6 +227,10 @@ struct Node
|
||||
// OTFUNC
|
||||
Node* rcvr;
|
||||
|
||||
// ONAME
|
||||
Node* ntype;
|
||||
Node* defn;
|
||||
|
||||
// ONAME func param with PHEAP
|
||||
Node* heapaddr; // temp holding heap address of param
|
||||
Node* stackparam; // OPARAM node referring to stack copy of param
|
||||
@ -601,7 +605,7 @@ EXTERN int loophack;
|
||||
|
||||
EXTERN uint32 iota;
|
||||
EXTERN NodeList* lastconst;
|
||||
EXTERN Type* lasttype;
|
||||
EXTERN Node* lasttype;
|
||||
EXTERN int32 vargen;
|
||||
EXTERN int32 exportgen;
|
||||
EXTERN int32 maxarg;
|
||||
@ -831,8 +835,8 @@ void dodclvar(Node*, Type*, NodeList**);
|
||||
Type* dodcltype(Type*);
|
||||
void updatetype(Type*, Type*);
|
||||
void dodclconst(Node*, Node*);
|
||||
void defaultlit(Node*, Type*);
|
||||
void defaultlit2(Node*, Node*);
|
||||
void defaultlit(Node**, Type*);
|
||||
void defaultlit2(Node**, Node**);
|
||||
int structcount(Type*);
|
||||
void addmethod(Node*, Type*, int);
|
||||
Node* methodname(Node*, Type*);
|
||||
@ -860,6 +864,7 @@ void addtyp(Type*, int);
|
||||
void addconst(Node*, Node*, int);
|
||||
Node* fakethis(void);
|
||||
int isifacemethod(Type*);
|
||||
Node* dclname(Sym*);
|
||||
Node* newname(Sym*);
|
||||
Node* oldname(Sym*);
|
||||
Type* newtype(Sym*);
|
||||
@ -873,10 +878,10 @@ void defercheckwidth(void);
|
||||
void resumecheckwidth(void);
|
||||
Node* embedded(Sym*);
|
||||
NodeList* variter(NodeList*, Type*, NodeList*);
|
||||
void constiter(NodeList*, Type*, NodeList*);
|
||||
NodeList* constiter(NodeList*, Node*, NodeList*);
|
||||
|
||||
void funclit0(Type*);
|
||||
Node* funclit1(Type*, NodeList*);
|
||||
Node* funclit0(Node*);
|
||||
Node* funclit1(Node*, NodeList*);
|
||||
Node* unsafenmagic(Node*, NodeList*);
|
||||
|
||||
/*
|
||||
@ -929,7 +934,7 @@ void walkexprlist(NodeList*, int, NodeList**);
|
||||
void walkconv(Node*, NodeList**);
|
||||
void walkdottype(Node*, NodeList**);
|
||||
void walkas(Node*);
|
||||
void walkbool(Node*);
|
||||
void walkbool(Node**);
|
||||
void walkswitch(Node*);
|
||||
void walkselect(Node*);
|
||||
void walkdot(Node*, NodeList**);
|
||||
@ -968,12 +973,14 @@ Node* selectas(Node*, Node*, NodeList**);
|
||||
Node* old2new(Node*, Type*, NodeList**);
|
||||
void addrescapes(Node*);
|
||||
void heapmoves(void);
|
||||
void walkdeflist(NodeList*);
|
||||
void walkdef(Node*);
|
||||
|
||||
/*
|
||||
* const.c
|
||||
*/
|
||||
void convlit1(Node*, Type*, int);
|
||||
void convlit(Node*, Type*);
|
||||
void convlit1(Node**, Type*, int);
|
||||
void convlit(Node**, Type*);
|
||||
void evconst(Node*);
|
||||
int cmpslit(Node *l, Node *r);
|
||||
int smallintconst(Node*);
|
||||
|
||||
@ -64,24 +64,25 @@
|
||||
%type <node> for_body for_header for_stmt if_header if_stmt
|
||||
%type <node> keyval labelname name
|
||||
%type <node> name_or_type
|
||||
%type <node> new_name oexpr
|
||||
%type <node> new_name dcl_name oexpr
|
||||
%type <node> onew_name
|
||||
%type <node> osimple_stmt pexpr
|
||||
%type <node> pseudocall range_stmt select_stmt
|
||||
%type <node> simple_stmt
|
||||
%type <node> switch_stmt uexpr
|
||||
%type <node> xfndcl
|
||||
%type <node> xfndcl typedcl
|
||||
|
||||
%type <list> xdcl fnbody common_dcl fnres switch_body loop_body
|
||||
%type <list> name_list expr_list keyval_list braced_keyval_list expr_or_type_list xdcl_list
|
||||
%type <list> xdcl fnbody fnres switch_body loop_body dcl_name_list
|
||||
%type <list> new_name_list expr_list keyval_list braced_keyval_list expr_or_type_list xdcl_list
|
||||
%type <list> oexpr_list oexpr_or_type_list caseblock_list stmt_list oarg_type_list arg_type_list
|
||||
%type <list> interfacedcl_list interfacedcl vardcl vardcl_list structdcl structdcl_list
|
||||
%type <list> common_dcl constdcl constdcl1 constdcl_list typedcl_list
|
||||
|
||||
%type <type> type
|
||||
%type <node> convtype dotdotdot
|
||||
%type <node> indcl interfacetype structtype
|
||||
%type <type> new_type typedclname fnlitdcl fntype
|
||||
%type <node> chantype non_chan_type othertype non_fn_type
|
||||
%type <type> new_type typedclname
|
||||
%type <node> chantype non_chan_type othertype non_fn_type fntype fnlitdcl
|
||||
|
||||
%type <sym> hidden_importsym hidden_pkg_importsym
|
||||
|
||||
@ -266,6 +267,7 @@ import_done:
|
||||
}
|
||||
my->def = nod(OPACK, N, N);
|
||||
my->def->sym = import;
|
||||
import->block = -1; // above top level
|
||||
}
|
||||
|
||||
/*
|
||||
@ -298,11 +300,13 @@ common_dcl:
|
||||
$$ = $2;
|
||||
if(yylast == LSEMIBRACE)
|
||||
yyoptsemi(0);
|
||||
// walkdeflist($2);
|
||||
}
|
||||
| LVAR '(' vardcl_list osemi ')'
|
||||
{
|
||||
$$ = $3;
|
||||
yyoptsemi(0);
|
||||
// walkdeflist($3);
|
||||
}
|
||||
| LVAR '(' ')'
|
||||
{
|
||||
@ -314,6 +318,7 @@ common_dcl:
|
||||
$$ = nil;
|
||||
iota = 0;
|
||||
lastconst = nil;
|
||||
walkdeflist($2);
|
||||
}
|
||||
| LCONST '(' constdcl osemi ')'
|
||||
{
|
||||
@ -321,6 +326,7 @@ common_dcl:
|
||||
iota = 0;
|
||||
lastconst = nil;
|
||||
yyoptsemi(0);
|
||||
walkdeflist($3);
|
||||
}
|
||||
| LCONST '(' constdcl ';' constdcl_list osemi ')'
|
||||
{
|
||||
@ -328,6 +334,7 @@ common_dcl:
|
||||
iota = 0;
|
||||
lastconst = nil;
|
||||
yyoptsemi(0);
|
||||
walkdeflist(concat($3, $5));
|
||||
}
|
||||
| LCONST '(' ')'
|
||||
{
|
||||
@ -337,12 +344,14 @@ common_dcl:
|
||||
| LTYPE typedcl
|
||||
{
|
||||
$$ = nil;
|
||||
// $$ = list1($2);
|
||||
if(yylast == LSEMIBRACE)
|
||||
yyoptsemi(0);
|
||||
}
|
||||
| LTYPE '(' typedcl_list osemi ')'
|
||||
{
|
||||
$$ = nil;
|
||||
// $$ = $3;
|
||||
yyoptsemi(0);
|
||||
}
|
||||
| LTYPE '(' ')'
|
||||
@ -358,38 +367,38 @@ varoptsemi:
|
||||
}
|
||||
|
||||
vardcl:
|
||||
name_list type varoptsemi
|
||||
dcl_name_list type varoptsemi
|
||||
{
|
||||
$$ = variter($1, $2, nil);
|
||||
}
|
||||
| name_list type varoptsemi '=' expr_list
|
||||
| dcl_name_list type varoptsemi '=' expr_list
|
||||
{
|
||||
$$ = variter($1, $2, $5);
|
||||
}
|
||||
| name_list '=' expr_list
|
||||
| dcl_name_list '=' expr_list
|
||||
{
|
||||
$$ = variter($1, T, $3);
|
||||
}
|
||||
|
||||
constdcl:
|
||||
name_list type '=' expr_list
|
||||
dcl_name_list ntype '=' expr_list
|
||||
{
|
||||
constiter($1, $2, $4);
|
||||
$$ = constiter($1, $2, $4);
|
||||
}
|
||||
| name_list '=' expr_list
|
||||
| dcl_name_list '=' expr_list
|
||||
{
|
||||
constiter($1, T, $3);
|
||||
$$ = constiter($1, N, $3);
|
||||
}
|
||||
|
||||
constdcl1:
|
||||
constdcl
|
||||
| name_list type
|
||||
| dcl_name_list ntype
|
||||
{
|
||||
constiter($1, $2, nil);
|
||||
$$ = constiter($1, $2, nil);
|
||||
}
|
||||
| name_list
|
||||
| dcl_name_list
|
||||
{
|
||||
constiter($1, T, nil);
|
||||
$$ = constiter($1, N, nil);
|
||||
}
|
||||
|
||||
typedclname:
|
||||
@ -944,6 +953,12 @@ new_name:
|
||||
$$ = newname($1);
|
||||
}
|
||||
|
||||
dcl_name:
|
||||
sym
|
||||
{
|
||||
$$ = dclname($1);
|
||||
}
|
||||
|
||||
new_type:
|
||||
sym
|
||||
{
|
||||
@ -1015,7 +1030,7 @@ type:
|
||||
|
||||
ntype:
|
||||
chantype
|
||||
| fntype { $$ = typenod($1); }
|
||||
| fntype
|
||||
| othertype
|
||||
| '(' ntype ')'
|
||||
{
|
||||
@ -1023,7 +1038,7 @@ ntype:
|
||||
}
|
||||
|
||||
non_chan_type:
|
||||
fntype { $$ = typenod($1); }
|
||||
fntype
|
||||
| othertype
|
||||
| '(' ntype ')'
|
||||
{
|
||||
@ -1135,7 +1150,7 @@ xfndcl:
|
||||
}
|
||||
|
||||
fndcl:
|
||||
new_name '(' oarg_type_list ')' fnres
|
||||
dcl_name '(' oarg_type_list ')' fnres
|
||||
{
|
||||
b0stack = dclstack; // mark base for fn literals
|
||||
$$ = nod(ODCLFUNC, N, N);
|
||||
@ -1168,15 +1183,16 @@ fndcl:
|
||||
fntype:
|
||||
LFUNC '(' oarg_type_list ')' fnres
|
||||
{
|
||||
$$ = functype(N, $3, $5);
|
||||
$$ = nod(OTFUNC, N, N);
|
||||
$$->list = $3;
|
||||
$$->rlist = $5;
|
||||
}
|
||||
|
||||
fnlitdcl:
|
||||
fntype
|
||||
{
|
||||
markdcl();
|
||||
$$ = $1;
|
||||
funclit0($$);
|
||||
$$ = funclit0($$);
|
||||
}
|
||||
|
||||
fnliteral:
|
||||
@ -1236,10 +1252,19 @@ vardcl_list:
|
||||
constdcl_list:
|
||||
constdcl1
|
||||
| constdcl_list ';' constdcl1
|
||||
{
|
||||
$$ = concat($1, $3);
|
||||
}
|
||||
|
||||
typedcl_list:
|
||||
typedcl
|
||||
{
|
||||
$$ = list1($1);
|
||||
}
|
||||
| typedcl_list ';' typedcl
|
||||
{
|
||||
$$ = list($1, $3);
|
||||
}
|
||||
|
||||
structdcl_list:
|
||||
structdcl
|
||||
@ -1256,7 +1281,7 @@ interfacedcl_list:
|
||||
}
|
||||
|
||||
structdcl:
|
||||
name_list ntype oliteral
|
||||
new_name_list ntype oliteral
|
||||
{
|
||||
NodeList *l;
|
||||
|
||||
@ -1298,7 +1323,7 @@ embed:
|
||||
}
|
||||
|
||||
interfacedcl:
|
||||
name_list indcl
|
||||
new_name_list indcl
|
||||
{
|
||||
NodeList *l;
|
||||
|
||||
@ -1447,14 +1472,24 @@ stmt_list:
|
||||
$$ = list($$, $3);
|
||||
}
|
||||
|
||||
name_list:
|
||||
name
|
||||
new_name_list:
|
||||
new_name
|
||||
{
|
||||
$$ = list1(newname($1->sym));
|
||||
$$ = list1($1);
|
||||
}
|
||||
| name_list ',' name
|
||||
| new_name_list ',' new_name
|
||||
{
|
||||
$$ = list($1, newname($3->sym));
|
||||
$$ = list($1, $3);
|
||||
}
|
||||
|
||||
dcl_name_list:
|
||||
dcl_name
|
||||
{
|
||||
$$ = list1($1);
|
||||
}
|
||||
| dcl_name_list ',' dcl_name
|
||||
{
|
||||
$$ = list($1, $3);
|
||||
}
|
||||
|
||||
expr_list:
|
||||
|
||||
@ -1345,18 +1345,22 @@ lexinit(void)
|
||||
v.ctype = CTNIL;
|
||||
s->def = nodlit(v);
|
||||
s->def->sym = s;
|
||||
s->block = -1; // above top level
|
||||
|
||||
s = lookup("true");
|
||||
s->def = nodbool(1);
|
||||
s->def->sym = s;
|
||||
s->block = -1; // above top level
|
||||
|
||||
s = lookup("false");
|
||||
s->def = nodbool(0);
|
||||
s->def->sym = s;
|
||||
s->block = -1; // above top level
|
||||
|
||||
s = lookup("iota");
|
||||
s->def = nodintconst(iota);
|
||||
s->def->iota = 1; // flag to reevaluate on copy
|
||||
s->block = -1; // above top level
|
||||
|
||||
// logically, the type of a string literal.
|
||||
// types[TSTRING] is the named type string
|
||||
@ -1450,6 +1454,7 @@ mkpackage(char* pkg)
|
||||
s = lookup(package);
|
||||
s->def = nod(OPACK, N, N);
|
||||
s->def->sym = s;
|
||||
s->block = -1; // above top level
|
||||
|
||||
if(outfile == nil) {
|
||||
p = strrchr(infile, '/');
|
||||
|
||||
@ -575,6 +575,16 @@ dodump(Node *n, int dep)
|
||||
break;
|
||||
}
|
||||
|
||||
if(n->ntype != nil) {
|
||||
indent(dep);
|
||||
print("%O-ntype\n", n->op);
|
||||
dodump(n->ntype, dep+1);
|
||||
}
|
||||
if(n->defn != nil) {
|
||||
indent(dep);
|
||||
print("%O-defn\n", n->op);
|
||||
dodump(n->defn, dep+1);
|
||||
}
|
||||
if(n->list != nil) {
|
||||
indent(dep);
|
||||
print("%O-list\n", n->op);
|
||||
@ -597,7 +607,7 @@ dumplist(char *s, NodeList *l)
|
||||
void
|
||||
dump(char *s, Node *n)
|
||||
{
|
||||
print("%s\n", s);
|
||||
print("%s [%p]\n", s, n);
|
||||
dodump(n, 1);
|
||||
}
|
||||
|
||||
@ -1360,6 +1370,8 @@ treecopy(Node *n)
|
||||
m->left = treecopy(n->left);
|
||||
m->right = treecopy(n->right);
|
||||
m->list = listtreecopy(n->list);
|
||||
if(m->defn)
|
||||
abort();
|
||||
break;
|
||||
|
||||
case OLITERAL:
|
||||
@ -1367,13 +1379,11 @@ treecopy(Node *n)
|
||||
m = nodintconst(iota);
|
||||
break;
|
||||
}
|
||||
m = nod(OXXX, N, N);
|
||||
*m = *n;
|
||||
break;
|
||||
|
||||
// fall through
|
||||
case ONONAME:
|
||||
case ONAME:
|
||||
m = nod(OXXX, N, N);
|
||||
*m = *n;
|
||||
case OTYPE:
|
||||
m = n;
|
||||
break;
|
||||
}
|
||||
return m;
|
||||
|
||||
@ -237,8 +237,11 @@ csort(Case *l, int(*f)(Case*, Case*))
|
||||
* walktype
|
||||
*/
|
||||
Type*
|
||||
sw0(Node *c, Type *place, int arg)
|
||||
sw0(Node **cp, Type *place, int arg)
|
||||
{
|
||||
Node *c;
|
||||
|
||||
c = *cp;
|
||||
if(c == N)
|
||||
return T;
|
||||
switch(c->op) {
|
||||
@ -264,8 +267,11 @@ sw0(Node *c, Type *place, int arg)
|
||||
* return the first type
|
||||
*/
|
||||
Type*
|
||||
sw1(Node *c, Type *place, int arg)
|
||||
sw1(Node **cp, Type *place, int arg)
|
||||
{
|
||||
Node *c;
|
||||
|
||||
c = *cp;
|
||||
if(place != T)
|
||||
return notideal(c->type);
|
||||
return place;
|
||||
@ -275,7 +281,7 @@ sw1(Node *c, Type *place, int arg)
|
||||
* return a suitable type
|
||||
*/
|
||||
Type*
|
||||
sw2(Node *c, Type *place, int arg)
|
||||
sw2(Node **cp, Type *place, int arg)
|
||||
{
|
||||
return types[TINT]; // botch
|
||||
}
|
||||
@ -285,13 +291,17 @@ sw2(Node *c, Type *place, int arg)
|
||||
* is compat with all the cases
|
||||
*/
|
||||
Type*
|
||||
sw3(Node *c, Type *place, int arg)
|
||||
sw3(Node **cp, Type *place, int arg)
|
||||
{
|
||||
Node *c;
|
||||
|
||||
c = *cp;
|
||||
if(place == T)
|
||||
return c->type;
|
||||
if(c->type == T)
|
||||
c->type = place;
|
||||
convlit(c, place);
|
||||
convlit(cp, place);
|
||||
c = *cp;
|
||||
if(!ascompat(place, c->type))
|
||||
badtype(OSWITCH, place, c->type);
|
||||
return place;
|
||||
@ -303,7 +313,7 @@ sw3(Node *c, Type *place, int arg)
|
||||
* types to cases and switch
|
||||
*/
|
||||
Type*
|
||||
walkcases(Node *sw, Type*(*call)(Node*, Type*, int arg), int arg)
|
||||
walkcases(Node *sw, Type*(*call)(Node**, Type*, int arg), int arg)
|
||||
{
|
||||
Node *n;
|
||||
NodeList *l;
|
||||
@ -311,7 +321,7 @@ walkcases(Node *sw, Type*(*call)(Node*, Type*, int arg), int arg)
|
||||
int32 lno;
|
||||
|
||||
lno = setlineno(sw);
|
||||
place = call(sw->ntest, T, arg);
|
||||
place = call(&sw->ntest, T, arg);
|
||||
|
||||
for(l=sw->list; l; l=l->next) {
|
||||
n = l->n;
|
||||
@ -321,7 +331,7 @@ walkcases(Node *sw, Type*(*call)(Node*, Type*, int arg), int arg)
|
||||
|
||||
if(n->left != N && !n->diag) {
|
||||
setlineno(n);
|
||||
place = call(n->left, place, arg);
|
||||
place = call(&n->left, place, arg);
|
||||
}
|
||||
}
|
||||
lineno = lno;
|
||||
@ -597,7 +607,7 @@ exprswitch(Node *sw)
|
||||
if(t == T)
|
||||
return;
|
||||
walkcases(sw, sw3, arg);
|
||||
convlit(sw->ntest, t);
|
||||
convlit(&sw->ntest, t);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@ -103,6 +103,75 @@ gettype(Node *n, NodeList **init)
|
||||
dump("after gettype", n);
|
||||
}
|
||||
|
||||
void
|
||||
walkdeflist(NodeList *l)
|
||||
{
|
||||
for(; l; l=l->next)
|
||||
walkdef(l->n);
|
||||
}
|
||||
|
||||
void
|
||||
walkdef(Node *n)
|
||||
{
|
||||
int lno;
|
||||
NodeList *init;
|
||||
Node *e;
|
||||
Type *t;
|
||||
|
||||
lno = lineno;
|
||||
setlineno(n);
|
||||
|
||||
if(n->op == ONONAME) {
|
||||
if(!n->diag) {
|
||||
n->diag = 1;
|
||||
yyerror("undefined: %S", n->sym);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if(n->type != T || n->diag)
|
||||
return;
|
||||
|
||||
if(n->trecur) {
|
||||
// TODO(rsc): better loop message
|
||||
fatal("loop");
|
||||
}
|
||||
n->trecur = 1;
|
||||
|
||||
init = nil;
|
||||
switch(n->op) {
|
||||
case OLITERAL:
|
||||
if(n->ntype != N) {
|
||||
walkexpr(n->ntype, Etype, &init);
|
||||
n->type = n->ntype->type;
|
||||
n->ntype = N;
|
||||
if(n->type == T) {
|
||||
n->diag = 1;
|
||||
goto ret;
|
||||
}
|
||||
}
|
||||
e = n->defn;
|
||||
if(e == N) {
|
||||
dump("walkdef", n);
|
||||
}
|
||||
walkexpr(e, Erv, &init);
|
||||
if(e->op != OLITERAL) {
|
||||
yyerror("const initializer must be constant");
|
||||
goto ret;
|
||||
}
|
||||
t = n->type;
|
||||
if(t != T)
|
||||
convlit(&e, t);
|
||||
n->val = e->val;
|
||||
n->type = e->type;
|
||||
break;
|
||||
}
|
||||
|
||||
ret:
|
||||
lineno = lno;
|
||||
n->trecur = 0;
|
||||
}
|
||||
|
||||
void
|
||||
walkstmtlist(NodeList *l)
|
||||
{
|
||||
@ -129,6 +198,7 @@ walkstmt(Node *n)
|
||||
yyerror("%S is not a top level statement", n->sym);
|
||||
else
|
||||
yyerror("%O is not a top level statement", n->op);
|
||||
dump("nottop", n);
|
||||
break;
|
||||
|
||||
case OASOP:
|
||||
@ -177,14 +247,14 @@ walkstmt(Node *n)
|
||||
|
||||
case OFOR:
|
||||
walkstmtlist(n->ninit);
|
||||
walkbool(n->ntest);
|
||||
walkbool(&n->ntest);
|
||||
walkstmt(n->nincr);
|
||||
walkstmtlist(n->nbody);
|
||||
break;
|
||||
|
||||
case OIF:
|
||||
walkstmtlist(n->ninit);
|
||||
walkbool(n->ntest);
|
||||
walkbool(&n->ntest);
|
||||
walkstmtlist(n->nbody);
|
||||
walkstmtlist(n->nelse);
|
||||
break;
|
||||
@ -290,6 +360,16 @@ reswitch:
|
||||
t = T;
|
||||
et = Txxx;
|
||||
|
||||
switch(n->op) {
|
||||
case ONAME:
|
||||
case OTYPE:
|
||||
case OLITERAL:
|
||||
case ONONAME:
|
||||
if(n->sym != S && n->type == T)
|
||||
walkdef(n);
|
||||
break;
|
||||
}
|
||||
|
||||
switch(n->op) {
|
||||
default:
|
||||
dump("walk", n);
|
||||
@ -367,6 +447,11 @@ reswitch:
|
||||
n->type = sortinter(n->type);
|
||||
goto ret;
|
||||
|
||||
case OTFUNC:
|
||||
n->op = OTYPE;
|
||||
n->type = functype(n->left, n->list, n->rlist);
|
||||
goto ret;
|
||||
|
||||
case OKEY:
|
||||
walkexpr(n->left, top | typeok, init);
|
||||
n = n->right;
|
||||
@ -408,7 +493,7 @@ reswitch:
|
||||
|
||||
case ONONAME:
|
||||
s = n->sym;
|
||||
if(s->undef == 0) {
|
||||
if(n->diag == 0) {
|
||||
s->undef = 1;
|
||||
n->diag = 1;
|
||||
yyerror("undefined: %S", s);
|
||||
@ -455,7 +540,7 @@ reswitch:
|
||||
}
|
||||
|
||||
walkexpr(n->left, Erv | Etype, init);
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
|
||||
t = n->left->type;
|
||||
if(t == T)
|
||||
@ -766,7 +851,7 @@ reswitch:
|
||||
goto ret;
|
||||
// do NOT defaultlit n->left.
|
||||
// let parent defaultlit or convlit instead.
|
||||
defaultlit(n->right, types[TUINT]);
|
||||
defaultlit(&n->right, types[TUINT]);
|
||||
if(n->left->type == T || n->right->type == T)
|
||||
goto ret;
|
||||
if(issigned[n->right->type->etype] || !isint[n->right->type->etype])
|
||||
@ -802,7 +887,7 @@ reswitch:
|
||||
evconst(n);
|
||||
if(n->op == OLITERAL)
|
||||
goto ret;
|
||||
defaultlit2(n->left, n->right);
|
||||
defaultlit2(&n->left, &n->right);
|
||||
if(n->left->type == T || n->right->type == T)
|
||||
goto ret;
|
||||
if(!eqtype(n->left->type, n->right->type))
|
||||
@ -869,7 +954,7 @@ reswitch:
|
||||
n->left = n->list->n;
|
||||
}
|
||||
walkexpr(n->left, Erv, init);
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
implicitstar(&n->left);
|
||||
t = n->left->type;
|
||||
if(t == T)
|
||||
@ -904,7 +989,7 @@ reswitch:
|
||||
n->left = n->list->n;
|
||||
}
|
||||
walkexpr(n->left, Erv, init);
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
implicitstar(&n->left);
|
||||
t = n->left->type;
|
||||
if(t == T)
|
||||
@ -930,7 +1015,7 @@ reswitch:
|
||||
if(n->left == N || n->right == N)
|
||||
goto ret;
|
||||
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
implicitstar(&n->left);
|
||||
|
||||
t = n->left->type;
|
||||
@ -939,14 +1024,14 @@ reswitch:
|
||||
|
||||
switch(t->etype) {
|
||||
default:
|
||||
defaultlit(n->right, T);
|
||||
defaultlit(&n->right, T);
|
||||
goto badt;
|
||||
|
||||
case TSTRING:
|
||||
// right side must be an int
|
||||
if(top != Erv)
|
||||
goto nottop;
|
||||
defaultlit(n->right, types[TINT]);
|
||||
defaultlit(&n->right, types[TINT]);
|
||||
if(n->right->type == T)
|
||||
break;
|
||||
if(!isint[n->right->type->etype])
|
||||
@ -956,7 +1041,7 @@ reswitch:
|
||||
|
||||
case TMAP:
|
||||
// right side must be map type
|
||||
defaultlit(n->right, t->down);
|
||||
defaultlit(&n->right, t->down);
|
||||
if(n->right->type == T)
|
||||
break;
|
||||
if(!eqtype(n->right->type, t->down))
|
||||
@ -968,7 +1053,7 @@ reswitch:
|
||||
|
||||
case TARRAY:
|
||||
// right side must be an int
|
||||
defaultlit(n->right, types[TINT]);
|
||||
defaultlit(&n->right, types[TINT]);
|
||||
if(n->right->type == T)
|
||||
break;
|
||||
if(!isint[n->right->type->etype])
|
||||
@ -1021,9 +1106,9 @@ reswitch:
|
||||
walkexpr(n->right, Erv, init);
|
||||
if(n->left == N || n->right == N)
|
||||
goto ret;
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(n->right->left, types[TUINT]);
|
||||
defaultlit(n->right->right, types[TUINT]);
|
||||
defaultlit(&n->left, T);
|
||||
defaultlit(&n->right->left, types[TUINT]);
|
||||
defaultlit(&n->right->right, types[TUINT]);
|
||||
implicitstar(&n->left);
|
||||
t = n->left->type;
|
||||
if(t == T)
|
||||
@ -1045,14 +1130,14 @@ reswitch:
|
||||
case ODOTINTER:
|
||||
if(top == Etop)
|
||||
goto nottop;
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
walkdot(n, init);
|
||||
goto ret;
|
||||
|
||||
case OADDR:
|
||||
if(top != Erv)
|
||||
goto nottop;
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
if(n->left->op == OCOMPOS) {
|
||||
walkexpr(n->left->right, Etype, init);
|
||||
n->left->type = n->left->right->type;
|
||||
@ -1121,7 +1206,7 @@ reswitch:
|
||||
if(n->left == N)
|
||||
goto ret;
|
||||
walkexpr(n->left, top | Etype, init);
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
if(n->left->op == OTYPE) {
|
||||
n->op = OTYPE;
|
||||
n->type = ptrto(n->left->type);
|
||||
@ -1361,12 +1446,16 @@ ret:
|
||||
}
|
||||
|
||||
void
|
||||
walkbool(Node *n)
|
||||
walkbool(Node **np)
|
||||
{
|
||||
Node *n;
|
||||
|
||||
n = *np;
|
||||
if(n == N)
|
||||
return;
|
||||
walkexpr(n, Erv, &n->ninit);
|
||||
defaultlit(n, T);
|
||||
defaultlit(np, T);
|
||||
n = *np;
|
||||
if(n->type != T && !eqtype(n->type, types[TBOOL]))
|
||||
yyerror("IF and FOR require a boolean type");
|
||||
}
|
||||
@ -1377,7 +1466,7 @@ walkdottype(Node *n, NodeList **init)
|
||||
walkexpr(n->left, Erv, init);
|
||||
if(n->left == N)
|
||||
return;
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
if(!isinter(n->left->type))
|
||||
yyerror("type assertion requires interface on left, have %T", n->left->type);
|
||||
if(n->right != N) {
|
||||
@ -1418,7 +1507,8 @@ walkconv(Node *n, NodeList **init)
|
||||
}
|
||||
|
||||
// otherwise, conversion.
|
||||
convlit1(l, t, 1);
|
||||
convlit1(&n->left, t, 1);
|
||||
l = n->left;
|
||||
if(l->type == T)
|
||||
return;
|
||||
|
||||
@ -1543,7 +1633,7 @@ selcase(Node *n, Node *var, NodeList **init)
|
||||
return N;
|
||||
}
|
||||
|
||||
convlit(c->right, t->type);
|
||||
convlit(&c->right, t->type);
|
||||
if(!ascompat(t->type, c->right->type)) {
|
||||
badtype(c->op, t->type, c->right->type);
|
||||
return N;
|
||||
@ -1608,7 +1698,7 @@ recv2:
|
||||
}
|
||||
|
||||
walkexpr(c->left, Elv, init); // check elem
|
||||
convlit(c->left, t->type);
|
||||
convlit(&c->left, t->type);
|
||||
if(!ascompat(t->type, c->left->type)) {
|
||||
badtype(c->op, t->type, c->left->type);
|
||||
return N;
|
||||
@ -1931,7 +2021,7 @@ ascompatee1(int op, Node *l, Node *r, NodeList **init)
|
||||
* a expression. called in
|
||||
* expr = expr
|
||||
*/
|
||||
convlit(r, l->type);
|
||||
convlit(&r, l->type);
|
||||
if(!ascompat(l->type, r->type)) {
|
||||
badtype(op, l->type, r->type);
|
||||
return nil;
|
||||
@ -2087,7 +2177,8 @@ mkdotargs(NodeList *lr0, NodeList *nn, Type *l, int fp, NodeList **init)
|
||||
return nil;
|
||||
}
|
||||
}
|
||||
defaultlit(r, T);
|
||||
defaultlit(&r, T);
|
||||
lr->n = r;
|
||||
if(r->type == T) // type check failed
|
||||
return nil;
|
||||
|
||||
@ -2254,7 +2345,7 @@ loop:
|
||||
}
|
||||
return nn;
|
||||
}
|
||||
convlit(r, l->type);
|
||||
convlit(&r, l->type);
|
||||
if(!ascompat(l->type, r->type)) {
|
||||
badtype(op, l->type, r->type);
|
||||
return nil;
|
||||
@ -2398,10 +2489,12 @@ prcompat(NodeList *all, int fmt, int dopanic)
|
||||
if(n->op == OLITERAL) {
|
||||
switch(n->val.ctype) {
|
||||
case CTINT:
|
||||
defaultlit(n, types[TINT64]);
|
||||
defaultlit(&n, types[TINT64]);
|
||||
l->n = n;
|
||||
break;
|
||||
case CTFLT:
|
||||
defaultlit(n, types[TFLOAT64]);
|
||||
defaultlit(&n, types[TFLOAT64]);
|
||||
l->n = n;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -2773,7 +2866,7 @@ mapop(Node *n, int top, NodeList **init)
|
||||
if(t == T)
|
||||
break;
|
||||
|
||||
convlit(n->right, t->down);
|
||||
convlit(&n->right, t->down);
|
||||
|
||||
if(!eqtype(n->right->type, t->down)) {
|
||||
badtype(n->op, n->right->type, t->down);
|
||||
@ -3029,7 +3122,7 @@ chanop(Node *n, int top, NodeList **init)
|
||||
|
||||
// chanrecv2(hchan *chan any) (elem any, pres bool);
|
||||
r = n->rlist->n;
|
||||
defaultlit(r->left, T);
|
||||
defaultlit(&r->left, T);
|
||||
t = fixchan(r->left->type);
|
||||
if(t == T)
|
||||
break;
|
||||
@ -3061,7 +3154,7 @@ chanop(Node *n, int top, NodeList **init)
|
||||
}
|
||||
|
||||
// chanrecv1(hchan *chan any) (elem any);
|
||||
defaultlit(n->left, T);
|
||||
defaultlit(&n->left, T);
|
||||
t = fixchan(n->left->type);
|
||||
if(t == T)
|
||||
break;
|
||||
@ -3673,7 +3766,7 @@ colas(NodeList *ll, NodeList *lr)
|
||||
case OCALLINTER:
|
||||
walkexpr(nr->left, Erv, &init);
|
||||
call:
|
||||
convlit(nr->left, types[TFUNC]);
|
||||
convlit(&nr->left, types[TFUNC]);
|
||||
t = nr->left->type;
|
||||
if(t == T)
|
||||
goto outl; // error already printed
|
||||
@ -3714,7 +3807,8 @@ colas(NodeList *ll, NodeList *lr)
|
||||
r = saver->n;
|
||||
|
||||
walkexpr(r, Erv, &init);
|
||||
defaultlit(r, T);
|
||||
defaultlit(&r, T);
|
||||
saver->n = r;
|
||||
a = mixedoldnew(l, r->type);
|
||||
n = list(n, a);
|
||||
}
|
||||
|
||||
@ -145,7 +145,7 @@ fixedbugs/bug049.go:6: illegal types for operand: EQ
|
||||
fixedbugs/bug050.go:3: package statement must be first
|
||||
|
||||
=========== fixedbugs/bug051.go
|
||||
fixedbugs/bug051.go:10: expression must be a constant
|
||||
fixedbugs/bug051.go:10: const initializer must be constant
|
||||
|
||||
=========== fixedbugs/bug062.go
|
||||
fixedbugs/bug062.go:6: illegal types for operand: AS
|
||||
@ -184,7 +184,7 @@ fixedbugs/bug074.go:6: invalid type for composite literal: string
|
||||
fixedbugs/bug074.go:6: invalid type for composite literal: string
|
||||
|
||||
=========== fixedbugs/bug081.go
|
||||
fixedbugs/bug081.go:5: undefined: x
|
||||
fixedbugs/bug081.go:5: fatal error: loop
|
||||
|
||||
=========== fixedbugs/bug083.go
|
||||
fixedbugs/bug083.dir/bug1.go:9: cannot refer to bug0.t0
|
||||
@ -202,7 +202,6 @@ M
|
||||
|
||||
=========== fixedbugs/bug103.go
|
||||
fixedbugs/bug103.go:8: assignment count mismatch: 1 = 0
|
||||
fixedbugs/bug103.go:8: undefined: x
|
||||
fixedbugs/bug103.go:8: function requires a return type
|
||||
fixedbugs/bug103.go:8: illegal types for operand: AS
|
||||
int
|
||||
|
||||
Loading…
Reference in New Issue
Block a user