mparith3.$O\
obj.$O\
print.$O\
+ range.$O\
reflect.$O\
select.$O\
sinit.$O\
return 0;
}
-Node*
-old2new(Node *n, Type *t, NodeList **init)
-{
- Node *l;
-
- if(!colasname(n)) {
- yyerror("left side of := must be a name");
- return n;
- }
- if(t != T && t->funarg) {
- yyerror("use of multi func value as single value in :=");
- return n;
- }
- l = newname(n->sym);
- dodclvar(l, t, init);
- return l;
-}
-
-Node*
-colas(NodeList *left, NodeList *right)
+void
+colasdefn(NodeList *left, Node *defn)
{
int nnew;
- Node *n, *as;
NodeList *l;
-
- if(count(left) == 1 && count(right) == 1)
- as = nod(OAS, left->n, right->n);
- else {
- as = nod(OAS2, N, N);
- as->list = left;
- as->rlist = right;
- }
- as->colas = 1;
+ Node *n;
nnew = 0;
for(l=left; l; l=l->next) {
nnew++;
n = newname(n->sym);
declare(n, dclcontext);
- if(as->op == OAS)
- as->left = n;
- n->defn = as;
- as->ninit = list(as->ninit, nod(ODCL, n, N));
+ n->defn = defn;
+ defn->ninit = list(defn->ninit, nod(ODCL, n, N));
l->n = n;
}
if(nnew == 0)
yyerror("no new variables on left side of :=");
+}
+
+Node*
+colas(NodeList *left, NodeList *right)
+{
+ Node *as;
+
+ as = nod(OAS2, N, N);
+ as->list = left;
+ as->rlist = right;
+ as->colas = 1;
+ colasdefn(left, as);
+
+ // make the tree prettier; not necessary
+ if(count(left) == 1 && count(right) == 1) {
+ as->left = as->list->n;
+ as->right = as->rlist->n;
+ as->list = nil;
+ as->rlist = nil;
+ as->op = OAS;
+ }
+
return as;
}
OCOMPSLICE, OCOMPMAP,
OCONV, OCONVNOP, OCONVA2S, OCONVIFACE, OCONVSLICE,
ODCL, ODCLFUNC, ODCLFIELD, ODCLARG,
- ODOT, ODOTPTR, ODOTMETH, ODOTINTER,
+ ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT,
ODOTTYPE,
OEQ, ONE, OLT, OLE, OGE, OGT,
OFUNC,
void walkdottype(Node*, NodeList**);
void walkas(Node*);
void walkswitch(Node*);
+void walkrange(Node*);
void walkselect(Node*);
void walkdot(Node*, NodeList**);
void walkexpr(Node**, NodeList**);
void runifacechecks(void);
Node* convas(Node*, NodeList**);
Node* colas(NodeList*, NodeList*);
-Node* dorange(Node*);
+void colasdefn(NodeList*, Node*);
NodeList* reorder1(NodeList*);
NodeList* reorder3(NodeList*);
NodeList* reorder4(NodeList*);
Node* structlit(Node*, Node*, NodeList**);
Node* arraylit(Node*, Node*, NodeList**);
Node* maplit(Node*, Node*, NodeList**);
-Node* selectas(Node*, Node*, NodeList**);
-Node* old2new(Node*, Type*, NodeList**);
void heapmoves(void);
void walkdeflist(NodeList*);
void walkdef(Node*);
void typechecklist(NodeList*, int);
void typecheckswitch(Node*);
void typecheckselect(Node*);
+void typecheckrange(Node*);
Node* typecheckconv(Node*, Node*, Type*, int);
+int checkconv(Type*, Type*, int, int*, int*);
Node* typecheck(Node**, int);
/*
case:
LCASE expr_or_type_list ':'
{
- int e;
- Node *n;
+ Node *n, *ntype;
// will be converted to OCASE
// right will point to next case
$$ = nod(OXCASE, N, N);
if(typeswvar != N && typeswvar->right != N) {
// type switch
- n = $2->n;
+ ntype = $2->n;
if($2->next != nil)
yyerror("type switch case cannot be list");
- if(n->op == OLITERAL && n->val.ctype == CTNIL) {
+ if(ntype->op == OLITERAL && ntype->val.ctype == CTNIL) {
// case nil
$$->list = list1(nod(OTYPECASE, N, N));
break;
}
-
- // TODO: move
- e = nerrors;
- typecheck(&n, Etype | Erv);
- if(n->op == OTYPE) {
- n = old2new(typeswvar->right, n->type, &$$->ninit);
- $$->list = list1(nod(OTYPECASE, n, N));
- break;
- }
- // maybe typecheck found problems that keep
- // e from being valid even outside a type switch.
- // only complain if typecheck didn't print new errors.
- if(nerrors == e)
- yyerror("non-type case in type switch");
- $$->diag = 1;
+ n = newname(typeswvar->right->sym);
+ declare(n, dclcontext);
+ n->ntype = ntype;
+ $$->list = list1(nod(OTYPECASE, n, N));
} else {
// expr switch
$$->list = $2;
// done in casebody()
poptodcl();
$$ = nod(OXCASE, N, N);
-// $$->list = list1(nod(OAS, selectas($2, $4, &$$->ninit), $4));
$$->list = list1(colas(list1($2), list1($4)));
}
| LDEFAULT ':'
{
$$ = nod(ORANGE, N, $4);
$$->list = $1;
- $$->etype = 1;
+ $$->colas = 1;
+ colasdefn($1, $$);
}
for_header:
$$->ntest = $1;
}
| range_stmt
- {
- $$ = dorange($1);
- }
for_body:
for_header loop_body
$$ = oldname(s);
break;
}
- $$ = nod(ODOT, $1, newname($3));
- $$ = adddot($$);
+ $$ = nod(OXDOT, $1, newname($3));
}
| '(' expr_or_type ')'
{
$$ = oldname(s);
break;
}
- $$ = nod(ODOT, $1, newname($3));
- $$ = adddot($$);
+ $$ = nod(OXDOT, $1, newname($3));
}
othertype:
--- /dev/null
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+ * range
+ */
+
+#include "go.h"
+
+void
+typecheckrange(Node *n)
+{
+ int op, et;
+ Type *t, *t1, *t2;
+ Node *v1, *v2;
+ NodeList *ll;
+
+ // delicate little dance. see typecheckas2
+ for(ll=n->list; ll; ll=ll->next)
+ if(ll->n->defn != n)
+ typecheck(&ll->n, Erv);
+
+ typecheck(&n->right, Erv);
+ if((t = n->right->type) == T)
+ goto out;
+ n->type = t;
+
+ switch(t->etype) {
+ default:
+ yyerror("cannot range over %+N", n->right);
+ goto out;
+
+ case TARRAY:
+ t1 = types[TINT];
+ t2 = t->type;
+ break;
+
+ case TMAP:
+ t1 = t->down;
+ t2 = t->type;
+ break;
+
+ case TCHAN:
+ t1 = t->type;
+ t2 = nil;
+ if(count(n->list) == 2)
+ goto toomany;
+ break;
+
+ case TSTRING:
+ t1 = types[TINT];
+ t2 = types[TINT];
+ break;
+ }
+
+ if(count(n->list) > 2) {
+ toomany:
+ yyerror("too many variables in range");
+ }
+
+ v1 = n->list->n;
+ v2 = N;
+ if(n->list->next)
+ v2 = n->list->next->n;
+
+ if(v1->defn == n)
+ v1->type = t1;
+ else if(v1->type != T && checkconv(t1, v1->type, 0, &op, &et) < 0)
+ yyerror("cannot assign type %T to %+N", t1, v1);
+ if(v2) {
+ if(v2->defn == n)
+ v2->type = t2;
+ else if(v2->type != T && checkconv(t2, v2->type, 0, &op, &et) < 0)
+ yyerror("cannot assign type %T to %+N", t1, v1);
+ }
+
+out:
+ typechecklist(n->nbody, Etop);
+
+ // second half of dance
+ n->typecheck = 1;
+ for(ll=n->list; ll; ll=ll->next)
+ if(ll->n->typecheck == 0)
+ typecheck(&ll->n, Erv);
+}
+
+void
+walkrange(Node *n)
+{
+ Node *ohv1, *hv1, *hv2; // hidden (old) val 1, 2
+ Node *ha, *hit; // hidden aggregate, iterator
+ Node *a, *v1, *v2; // not hidden aggregate, val 1, 2
+ Node *fn;
+ NodeList *body, *init;
+ Type *th, *t;
+
+ t = n->type;
+ init = nil;
+
+ a = n->right;
+ if(t->etype == TSTRING && !eqtype(t, types[TSTRING])) {
+ a = nod(OCONV, n->right, N);
+ a->type = types[TSTRING];
+ }
+ ha = nod(OXXX, N, N);
+ tempname(ha, a->type);
+ init = list(init, nod(OAS, ha, a));
+
+ v1 = n->list->n;
+ hv1 = N;
+
+ v2 = N;
+ if(n->list->next)
+ v2 = n->list->next->n;
+ hv2 = N;
+
+ switch(t->etype) {
+ default:
+ fatal("walkrange");
+
+ case TARRAY:
+ hv1 = nod(OXXX, N, n);
+ tempname(hv1, v1->type);
+
+ init = list(init, nod(OAS, hv1, N));
+ n->ntest = nod(OLT, hv1, nod(OLEN, ha, N));
+ n->nincr = nod(OASOP, hv1, nodintconst(1));
+ n->nincr->etype = OADD;
+ body = list1(nod(OAS, v1, hv1));
+ if(v2)
+ body = list(body, nod(OAS, v2, nod(OINDEX, ha, hv1)));
+ break;
+
+ case TMAP:
+ th = typ(TARRAY);
+ th->type = ptrto(types[TUINT8]);
+ th->bound = (sizeof(struct Hiter) + widthptr - 1) / widthptr;
+ hit = nod(OXXX, N, N);
+ tempname(hit, th);
+
+ fn = syslook("mapiterinit", 1);
+ argtype(fn, t->down);
+ argtype(fn, t->type);
+ argtype(fn, th);
+ init = list(init, mkcall1(fn, T, nil, ha, nod(OADDR, hit, N)));
+ n->ntest = nod(ONE, nod(OINDEX, hit, nodintconst(0)), nodnil());
+
+ fn = syslook("mapiternext", 1);
+ argtype(fn, th);
+ n->nincr = mkcall1(fn, T, nil, nod(OADDR, hit, N));
+
+ if(v2 == N) {
+ fn = syslook("mapiter1", 1);
+ argtype(fn, th);
+ argtype(fn, t->down);
+ a = nod(OAS, v1, mkcall1(fn, t->down, nil, nod(OADDR, hit, N)));
+ } else {
+ fn = syslook("mapiter2", 1);
+ argtype(fn, th);
+ argtype(fn, t->down);
+ argtype(fn, t->type);
+ a = nod(OAS2, N, N);
+ a->list = list(list1(v1), v2);
+ a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, nod(OADDR, hit, N)));
+ }
+ body = list1(a);
+ break;
+
+ case TCHAN:
+ hv1 = nod(OXXX, N, n);
+ tempname(hv1, v1->type);
+
+ n->ntest = nod(ONOT, nod(OCLOSED, ha, N), N);
+ n->ntest->ninit = list1(nod(OAS, hv1, nod(ORECV, ha, N)));
+ body = list1(nod(OAS, v1, hv1));
+ break;
+
+ case TSTRING:
+ ohv1 = nod(OXXX, N, N);
+ tempname(ohv1, types[TINT]);
+
+ hv1 = nod(OXXX, N, N);
+ tempname(hv1, types[TINT]);
+ init = list(init, nod(OAS, hv1, N));
+
+ if(v2 == N)
+ a = nod(OAS, hv1, mkcall("stringiter", types[TINT], nil, ha, hv1));
+ else {
+ hv2 = nod(OXXX, N, N);
+ tempname(hv2, types[TINT]);
+ a = nod(OAS2, N, N);
+ a->list = list(list1(hv1), hv2);
+ fn = syslook("stringiter2", 0);
+ a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, ha, hv1));
+ }
+ n->ntest = nod(ONE, hv1, nodintconst(0));
+ n->ntest->ninit = list(list1(nod(OAS, ohv1, hv1)), a);
+
+ body = list1(nod(OAS, v1, ohv1));
+ if(v2 != N)
+ body = list(body, nod(OAS, v2, hv2));
+ break;
+ }
+
+ n->op = OFOR;
+ typechecklist(init, Etop);
+ n->ninit = concat(n->ninit, init);
+ typechecklist(n->ntest->ninit, Etop);
+ typecheck(&n->ntest, Erv);
+ typecheck(&n->nincr, Etop);
+ typechecklist(body, Etop);
+ n->nbody = concat(body, n->nbody);
+ walkstmt(&n);
+}
+
#include "go.h"
-/*
- * declare v in
- * case v := <-chan // select and switch
- * called during parse
- */
-Node*
-selectas(Node *name, Node *expr, NodeList **init)
-{
- Type *t;
-
- if(expr == N || expr->op != ORECV)
- goto bad;
-
- walkexpr(&expr->left, init);
- t = expr->left->type;
- if(t == T)
- goto bad;
- if(t->etype != TCHAN)
- goto bad;
- t = t->type;
- return old2new(name, t, init);
-
-bad:
- return name;
-}
-
void
typecheckselect(Node *sel)
{
print("%O-ntype\n", n->op);
dodump(n->ntype, dep+1);
}
- if(n->defn != nil && n->defn->op != OAS && n->defn->op != OAS2) {
- 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);
print("%O-rlist\n", n->op);
dodumplist(n->rlist, dep+1);
}
+ if(n->nbody != nil) {
+ indent(dep);
+ print("%O-nbody\n", n->op);
+ dodumplist(n->nbody, dep+1);
+ }
}
void
yyerror("ambiguous DOT reference %T.%S", t, s);
// rebuild elided dots
- for(c=d-1; c>=0; c--) {
- n = nod(ODOT, n, n->right);
- n->left->right = newname(dotlist[c].field->sym);
- }
+ for(c=d-1; c>=0; c--)
+ n->left = nod(ODOT, n->left, newname(dotlist[c].field->sym));
ret:
return n;
}
args = list(args, l->n->left);
// generate call
- call = nod(OCALL, adddot(nod(ODOT, this->left, newname(method->sym))), N);
+ call = nod(OCALL, adddot(nod(OXDOT, this->left, newname(method->sym))), N);
call->list = args;
fn->nbody = list1(call);
if(method->type->outtuple > 0) {
*
* TODO:
* trailing ... section of function calls
- * range
*/
#include "go.h"
goto error;
goto ret;
+ case OXDOT:
+ n = adddot(n);
+ n->op = ODOT;
+ // fall through
case ODOT:
l = typecheck(&n->left, Erv);
if((t = l->type) == T)
typecheckswitch(n);
goto ret;
+ case ORANGE:
+ ok |= Etop;
+ typecheckrange(n);
+ goto ret;
+
case OTYPECASE:
ok |= Etop | Erv;
typecheck(&n->left, Erv);
return 1;
}
-static int
+int
checkconv(Type *nt, Type *t, int explicit, int *op, int *et)
{
*op = OCONV;
case OFOR:
walkstmtlist(n->ninit);
- walkexpr(&n->ntest, &n->ntest->ninit);
+ if(n->ntest != N) {
+ walkstmtlist(n->ntest->ninit);
+ walkexpr(&n->ntest, &n->ntest->ninit);
+ }
walkstmt(&n->nincr);
walkstmtlist(n->nbody);
break;
walkswitch(n);
break;
+ case ORANGE:
+ walkrange(n);
+ break;
+
case OXFALL:
yyerror("fallthrough statement out of place");
n->op = OFALL;
return n;
}
-/*
- * rewrite a range statement
- * k and v are names/new_names
- * m is an array or map
- * local is 0 (meaning =) or 1 (meaning :=)
- */
-Node*
-dorange(Node *nn)
-{
- Node *k, *v, *m;
- Node *n, *hv, *hc, *ha, *hk, *ohk, *on, *r, *a, *as;
- NodeList *init, *args;
- Type *t, *th;
- int local;
- NodeList *nl;
-
- if(nn->op != ORANGE)
- fatal("dorange not ORANGE");
-
- nl = nn->list;
- k = nl->n;
- if((nl = nl->next) != nil) {
- v = nl->n;
- nl = nl->next;
- } else
- v = N;
- if(nl != nil)
- yyerror("too many variables in range");
-
- n = nod(OFOR, N, N);
- init = nil;
-
- typecheck(&nn->right, Erv);
- m = nn->right;
- local = nn->etype;
-
- t = m->type;
- if(t == T)
- goto out;
- if(t->etype == TARRAY)
- goto ary;
- if(t->etype == TMAP)
- goto map;
- if(t->etype == TCHAN)
- goto chan;
- if(t->etype == TSTRING)
- goto strng;
-
- yyerror("range must be over map/array/chan/string");
- goto out;
-
-ary:
- hk = nod(OXXX, N, N); // hidden key
- tempname(hk, types[TINT]);
-
- ha = nod(OXXX, N, N); // hidden array
- tempname(ha, t);
-
- a = nod(OAS, hk, nodintconst(0));
- init = list(init, a);
-
- a = nod(OAS, ha, m);
- init = list(init, a);
-
- n->ntest = nod(OLT, hk, nod(OLEN, ha, N));
- n->nincr = nod(OASOP, hk, nodintconst(1));
- n->nincr->etype = OADD;
-
- if(local)
- k = old2new(k, hk->type, &init);
- n->nbody = list1(nod(OAS, k, hk));
-
- if(v != N) {
- if(local)
- v = old2new(v, t->type, &init);
- n->nbody = list(n->nbody,
- nod(OAS, v, nod(OINDEX, ha, hk)) );
- }
- goto out;
-
-map:
- th = typ(TARRAY);
- th->type = ptrto(types[TUINT8]);
- th->bound = (sizeof(struct Hiter) + types[tptr]->width - 1) /
- types[tptr]->width;
- hk = nod(OXXX, N, N); // hidden iterator
- tempname(hk, th); // hashmap hash_iter
-
- on = syslook("mapiterinit", 1);
- argtype(on, t->down);
- argtype(on, t->type);
- argtype(on, th);
- a = nod(OADDR, hk, N);
- r = nod(OCALL, on, N);
- r->list = list(list1(m), a);
-
- init = list(init, r);
-
- r = nod(OINDEX, hk, nodintconst(0));
- a = nod(OLITERAL, N, N);
- a->val.ctype = CTNIL;
- a->type = types[TNIL];
- r = nod(ONE, r, a);
- n->ntest = r;
-
- on = syslook("mapiternext", 1);
- argtype(on, th);
- r = nod(OADDR, hk, N);
- args = list1(r);
- r = nod(OCALL, on, N);
- r->list = args;
- n->nincr = r;
-
- if(local)
- k = old2new(k, t->down, &init);
- if(v == N) {
- on = syslook("mapiter1", 1);
- argtype(on, th);
- argtype(on, t->down);
- r = nod(OADDR, hk, N);
- args = list1(r);
- r = nod(OCALL, on, N);
- r->list = args;
- n->nbody = list1(nod(OAS, k, r));
- goto out;
- }
- if(local)
- v = old2new(v, t->type, &init);
- on = syslook("mapiter2", 1);
- argtype(on, th);
- argtype(on, t->down);
- argtype(on, t->type);
- r = nod(OADDR, hk, N);
- args = list1(r);
- r = nod(OCALL, on, N);
- r->list = args;
- as = nod(OAS2, N, N);
- as->list = list(list1(k), v);
- as->rlist = list1(r);
- n->nbody = list1(as);
- goto out;
-
-chan:
- if(v != N)
- yyerror("chan range can only have one variable");
-
- hc = nod(OXXX, N, N); // hidden chan
- tempname(hc, t);
-
- hv = nod(OXXX, N, N); // hidden value
- tempname(hv, t->type);
-
- a = nod(OAS, hc, m);
- init = list(init, a);
-
- a = nod(ORECV, hc, N);
- a = nod(OAS, hv, a);
- init = list(init, a);
-
- a = nod(OCLOSED, N, N);
- a->list = list1(hc);
- n->ntest = nod(ONOT, a, N);
- n->nincr = nod(OAS, hv, nod(ORECV, hc, N));
-
- if(local)
- k = old2new(k, hv->type, &init);
- n->nbody = list1(nod(OAS, k, hv));
-
- goto out;
-
-strng:
- hk = nod(OXXX, N, N); // hidden key
- tempname(hk, types[TINT]);
-
- ohk = nod(OXXX, N, N); // old hidden key
- tempname(ohk, types[TINT]);
-
- ha = nod(OXXX, N, N); // hidden string
- tempname(ha, types[TSTRING]);
-
- hv = N;
- if(v != N) {
- hv = nod(OXXX, N, N); // hidden value
- tempname(hv, types[TINT]);
- }
-
- if(local) {
- k = old2new(k, types[TINT], &init);
- if(v != N)
- v = old2new(v, types[TINT], &init);
- }
-
- // ha = s
- a = nod(OCONV, m, N);
- a->type = ha->type;
- a = nod(OAS, ha, a);
- init = list(init, a);
-
- // ohk = 0
- a = nod(OAS, ohk, nodintconst(0));
- init = list(init, a);
-
- // hk[,hv] = stringiter(ha,hk)
- if(v != N) {
- // hk,v = stringiter2(ha, hk)
- on = syslook("stringiter2", 0);
- a = nod(OCALL, on, N);
- a->list = list(list1(ha), nodintconst(0));
- as = nod(OAS2, N, N);
- as->list = list(list1(hk), hv);
- as->rlist = list1(a);
- a = as;
- } else {
- // hk = stringiter(ha, hk)
- on = syslook("stringiter", 0);
- a = nod(OCALL, on, N);
- a->list = list(list1(ha), nodintconst(0));
- a = nod(OAS, hk, a);
- }
- init = list(init, a);
-
- // while(hk != 0)
- n->ntest = nod(ONE, hk, nodintconst(0));
-
- // hk[,hv] = stringiter(ha,hk)
- if(v != N) {
- // hk,hv = stringiter2(ha, hk)
- on = syslook("stringiter2", 0);
- a = nod(OCALL, on, N);
- a->list = list(list1(ha), hk);
- as = nod(OAS2, N, N);
- as->list = list(list1(hk), hv);
- as->rlist = list1(a);
- a = as;
- } else {
- // hk = stringiter(ha, hk)
- on = syslook("stringiter", 0);
- a = nod(OCALL, on, N);
- a->list = list(list1(ha), hk);
- a = nod(OAS, hk, a);
- }
- n->nincr = a;
-
- // k,ohk[,v] = ohk,hk,[,hv]
- a = nod(OAS, k, ohk);
- n->nbody = list1(a);
- a = nod(OAS, ohk, hk);
- n->nbody = list(n->nbody, a);
- if(v != N) {
- a = nod(OAS, v, hv);
- n->nbody = list(n->nbody, a);
- }
-
-out:
- n->ninit = concat(n->ninit, init);
- return n;
-}
-
/*
* from ascompat[te]
* evaluating actual function arguments.