case TFORW: // should have been filled in
case TANY:
// dummy type; should be replaced before use.
- fatal("dowidth any");
+ if(!debug['A'])
+ fatal("dowidth any");
+ w = 1; // anything will do
break;
case TSTRING:
if(sizeof_String == 0)
"func sys.printpointer (? any)\n"
"func sys.printiface (? any)\n"
"func sys.printeface (? any)\n"
- "func sys.printarray (? any)\n"
+ "func sys.printslice (? any)\n"
"func sys.printnl ()\n"
"func sys.printsp ()\n"
"func sys.catstring (? string, ? string) (? string)\n"
"func sys.slicestring (? string, ? int, ? int) (? string)\n"
"func sys.indexstring (? string, ? int) (? uint8)\n"
"func sys.intstring (? int64) (? string)\n"
- "func sys.arraystring (? []uint8) (? string)\n"
- "func sys.arraystringi (? []int) (? string)\n"
+ "func sys.slicebytetostring (? []uint8) (? string)\n"
+ "func sys.sliceinttostring (? []int) (? string)\n"
"func sys.stringiter (? string, ? int) (? int)\n"
"func sys.stringiter2 (? string, ? int) (retk int, retv int)\n"
"func sys.ifaceI2E (iface any) (ret any)\n"
"func sys.efaceeq (i1 any, i2 any) (ret bool)\n"
"func sys.ifacethash (i1 any) (ret uint32)\n"
"func sys.efacethash (i1 any) (ret uint32)\n"
- "func sys.newmap (keysize int, valsize int, keyalg int, valalg int, hint int) (hmap map[any] any)\n"
+ "func sys.makemap (keysize int, valsize int, keyalg int, valalg int, hint int) (hmap map[any] any)\n"
"func sys.mapaccess1 (hmap map[any] any, key any) (val any)\n"
"func sys.mapaccess2 (hmap map[any] any, key any) (val any, pres bool)\n"
"func sys.mapassign1 (hmap map[any] any, key any, val any)\n"
"func sys.mapiternext (hiter *any)\n"
"func sys.mapiter1 (hiter *any) (key any)\n"
"func sys.mapiter2 (hiter *any) (key any, val any)\n"
- "func sys.newchan (elemsize int, elemalg int, hint int) (hchan chan any)\n"
+ "func sys.makechan (elemsize int, elemalg int, hint int) (hchan chan any)\n"
"func sys.chanrecv1 (hchan <-chan any) (elem any)\n"
"func sys.chanrecv2 (hchan <-chan any) (elem any, pres bool)\n"
"func sys.chansend1 (hchan chan<- any, elem any)\n"
"func sys.selectrecv (sel *uint8, hchan <-chan any, elem *any) (selected bool)\n"
"func sys.selectdefault (sel *uint8) (selected bool)\n"
"func sys.selectgo (sel *uint8)\n"
- "func sys.newarray (nel int, cap int, width int) (ary []any)\n"
- "func sys.arraysliced (old []any, lb int, hb int, width int) (ary []any)\n"
- "func sys.arrayslices (old *any, nel int, lb int, hb int, width int) (ary []any)\n"
- "func sys.arrays2d (old *any, nel int) (ary []any)\n"
+ "func sys.makeslice (nel int, cap int, width int) (ary []any)\n"
+ "func sys.sliceslice (old []any, lb int, hb int, width int) (ary []any)\n"
+ "func sys.slicearray (old *any, nel int, lb int, hb int, width int) (ary []any)\n"
+ "func sys.arraytoslice (old *any, nel int) (ary []any)\n"
"func sys.closure ()\n"
"func sys.int64div (? int64, ? int64) (? int64)\n"
"func sys.uint64div (? uint64, ? uint64) (? uint64)\n"
while(n->op == OCONVNOP)
n = n->left;
- // call to newarray - find nel argument
- nel = findarg(n, "nel", "newarray");
+ // call to makeslice - find nel argument
+ nel = findarg(n, "nel", "makeslice");
if(nel == N || !isslice(n->type))
goto no;
Type *ta, *tb;
Node *a;
- // call to newarray - find nel argument
- nel = findarg(n, "hint", "newmap");
+ // call to makemap - find len argument
+ nel = findarg(n, "hint", "makemap");
if(nel == N)
goto no;
ta = n->type;
if(r->op != OAS && r->op != OEMPTY)
continue;
- // first usage "nam = (newarray CALL args)"
+ // first usage "nam = (makeslice CALL args)"
if(r->right != N && sametmp(r->left, nam)) {
w = slicerewrite(r->right);
if(w == N)
if(r->op != OAS && r->op != OEMPTY)
continue;
- // first usage "nam = (newmap CALL args)"
+ // first usage "nam = (makemap CALL args)"
if(r->right != N && sametmp(r->left, nam)) {
w = maprewrite(r->right);
if(w == N)
func printpointer(any);
func printiface(any);
func printeface(any);
-func printarray(any);
+func printslice(any);
func printnl();
func printsp();
func slicestring(string, int, int) string;
func indexstring(string, int) byte;
func intstring(int64) string;
-func arraystring([]byte) string;
-func arraystringi([]int) string;
+func slicebytetostring([]byte) string;
+func sliceinttostring([]int) string;
func stringiter(string, int) int;
func stringiter2(string, int) (retk int, retv int);
func ifacethash(i1 any) (ret uint32);
func efacethash(i1 any) (ret uint32);
-func newmap(keysize int, valsize int,
+func makemap(keysize int, valsize int,
keyalg int, valalg int,
hint int) (hmap map[any]any);
func mapaccess1(hmap map[any]any, key any) (val any);
func mapiter1(hiter *any) (key any);
func mapiter2(hiter *any) (key any, val any);
-func newchan(elemsize int, elemalg int, hint int) (hchan chan any);
+func makechan(elemsize int, elemalg int, hint int) (hchan chan any);
func chanrecv1(hchan <-chan any) (elem any);
func chanrecv2(hchan <-chan any) (elem any, pres bool);
func chansend1(hchan chan<- any, elem any);
func selectdefault(sel *byte) (selected bool);
func selectgo(sel *byte);
-func newarray(nel int, cap int, width int) (ary []any);
-func arraysliced(old []any, lb int, hb int, width int) (ary []any);
-func arrayslices(old *any, nel int, lb int, hb int, width int) (ary []any);
-func arrays2d(old *any, nel int) (ary []any);
+func makeslice(nel int, cap int, width int) (ary []any);
+func sliceslice(old []any, lb int, hb int, width int) (ary []any);
+func slicearray(old *any, nel int, lb int, hb int, width int) (ary []any);
+func arraytoslice(old *any, nel int) (ary []any);
func closure(); // has args, but compiler fills in
walkexpr(&n->right->left, init);
walkexpr(&n->right->right, init);
// dynamic slice
- // arraysliced(old []any, lb int, hb int, width int) (ary []any)
+ // sliceslice(old []any, lb int, hb int, width int) (ary []any)
t = n->type;
- fn = syslook("arraysliced", 1);
+ fn = syslook("sliceslice", 1);
argtype(fn, t->type); // any-1
argtype(fn, t->type); // any-2
n = mkcall1(fn, t, init,
walkexpr(&n->right->left, init);
walkexpr(&n->right->right, init);
// static slice
- // arrayslices(old *any, nel int, lb int, hb int, width int) (ary []any)
+ // slicearray(old *any, nel int, lb int, hb int, width int) (ary []any)
t = n->type;
- fn = syslook("arrayslices", 1);
+ fn = syslook("slicearray", 1);
argtype(fn, n->left->type); // any-1
argtype(fn, t->type); // any-2
n = mkcall1(fn, t, init,
goto ret;
case OMAKECHAN:
- n = mkcall1(chanfn("newchan", 1, n->type), n->type, init,
+ n = mkcall1(chanfn("makechan", 1, n->type), n->type, init,
nodintconst(n->type->type->width),
nodintconst(algtype(n->type->type)),
conv(n->left, types[TINT]));
case OMAKEMAP:
t = n->type;
- fn = syslook("newmap", 1);
+ fn = syslook("makemap", 1);
argtype(fn, t->down); // any-1
argtype(fn, t->type); // any-2
goto ret;
case OMAKESLICE:
- // newarray(nel int, max int, width int) (ary []any)
+ // makeslice(nel int, max int, width int) (ary []any)
t = n->type;
- fn = syslook("newarray", 1);
+ fn = syslook("makeslice", 1);
argtype(fn, t->type); // any-1
n = mkcall1(fn, n->type, nil,
conv(n->left, types[TINT]),
goto ret;
case OARRAYBYTESTR:
- // arraystring([]byte) string;
- n = mkcall("arraystring", n->type, init, n->left);
+ // slicebytetostring([]byte) string;
+ n = mkcall("slicebytetostring", n->type, init, n->left);
goto ret;
case OARRAYRUNESTR:
- // arraystring([]byte) string;
- n = mkcall("arraystringi", n->type, init, n->left);
+ // sliceinttostring([]byte) string;
+ n = mkcall("sliceinttostring", n->type, init, n->left);
goto ret;
case OCMPIFACE:
goto ret;
case OCONVSLICE:
- // arrays2d(old *any, nel int) (ary []any)
- fn = syslook("arrays2d", 1);
+ // arraytoslice(old *any, nel int) (ary []any)
+ fn = syslook("arraytoslice", 1);
argtype(fn, n->left->type->type); // any-1
argtype(fn, n->type->type); // any-2
n = mkcall1(fn, n->type, init, n->left, nodintconst(n->left->type->type->bound));
on = syslook("printpointer", 1);
argtype(on, n->type); // any-1
} else if(isslice(n->type)) {
- on = syslook("printarray", 1);
+ on = syslook("printslice", 1);
argtype(on, n->type); // any-1
} else if(isint[et]) {
if(et == TUINT64)
vlrt.$O\
OFILES=\
- array.$O\
asm.$O\
cgocall.$O\
chan.$O\
rt0.$O\
sema.$O\
signal.$O\
+ slice.$O\
string.$O\
symtab.$O\
sys.$O\
Uint,
Uintptr,
String,
- Array,
+ Slice,
};
static struct {
"uint", 4,
"uintptr", 4,
"String", 8,
- "Array", 12,
+ "Slice", 12,
/* fixed size */
"float32", 4,
if(goarch != NULL && strcmp(goarch, "amd64") == 0) {
type_table[Uintptr].size = 8;
type_table[String].size = 16;
- type_table[Array].size = 8+4+4;
+ type_table[Slice].size = 8+4+4;
structround = 8;
}
}
if(elemalg >= nelem(algarray)) {
printf("chan(alg=%d)\n", elemalg);
- throw("sys·newchan: unsupported elem type");
+ throw("sys·makechan: unsupported elem type");
}
c = mal(sizeof(*c));
}
if(debug) {
- prints("newchan: chan=");
+ prints("makechan: chan=");
sys·printpointer(c);
prints("; elemsize=");
sys·printint(elemsize);
return c;
}
-// newchan(elemsize uint32, elemalg uint32, hint uint32) (hchan *chan any);
+// makechan(elemsize uint32, elemalg uint32, hint uint32) (hchan *chan any);
void
-sys·newchan(uint32 elemsize, uint32 elemalg, uint32 hint, Hchan *ret)
+sys·makechan(uint32 elemsize, uint32 elemalg, uint32 hint, Hchan *ret)
{
ret = makechan(elemsize, elemalg, hint);
FLUSH(&ret);
static int32 debug = 0;
-// newmap(keysize uint32, valsize uint32,
+// makemap(keysize uint32, valsize uint32,
// keyalg uint32, valalg uint32,
// hint uint32) (hmap *map[any]any);
Hmap*
if(keyalg >= nelem(algarray) || algarray[keyalg].hash == nohash) {
printf("map(keyalg=%d)\n", keyalg);
- throw("sys·newmap: unsupported map key type");
+ throw("sys·makemap: unsupported map key type");
}
if(valalg >= nelem(algarray)) {
printf("map(valalg=%d)\n", valalg);
- throw("sys·newmap: unsupported map value type");
+ throw("sys·makemap: unsupported map value type");
}
h = mal(sizeof(*h));
h->po2 = rnd(h->vo2+valsize, 1);
if(debug) {
- printf("newmap: map=%p; keysize=%d; valsize=%d; keyalg=%d; valalg=%d; offsets=%d,%d; %d,%d,%d; %d,%d,%d\n",
+ printf("makemap: map=%p; keysize=%d; valsize=%d; keyalg=%d; valalg=%d; offsets=%d,%d; %d,%d,%d; %d,%d,%d\n",
h, keysize, valsize, keyalg, valalg, h->ko0, h->vo0, h->ko1, h->vo1, h->po1, h->ko2, h->vo2, h->po2);
}
return h;
}
-// newmap(keysize uint32, valsize uint32,
+// makemap(keysize uint32, valsize uint32,
// keyalg uint32, valalg uint32,
// hint uint32) (hmap *map[any]any);
void
-sys·newmap(uint32 keysize, uint32 valsize,
+sys·makemap(uint32 keysize, uint32 valsize,
uint32 keyalg, uint32 valalg, uint32 hint,
Hmap *ret)
{
Itab *m;
UncommonType *x;
- if(inter->mhdr.nel == 0)
+ if(inter->mhdr.len == 0)
throw("internal error - misuse of itab");
// easy case
}
}
- ni = inter->mhdr.nel;
+ ni = inter->mhdr.len;
m = malloc(sizeof(*m) + ni*sizeof m->fun[0]);
m->inter = inter;
m->type = type;
// so can iterate over both in lock step;
// the loop is O(ni+nt) not O(ni*nt).
i = inter->m;
- ei = i + inter->mhdr.nel;
+ ei = i + inter->mhdr.len;
t = x->m;
- et = t + x->mhdr.nel;
+ et = t + x->mhdr.len;
for(; i < ei; i++) {
ihash = i->hash;
iname = i->name;
InterfaceType *t;
t = (InterfaceType*)gettype(typ);
- if(t->mhdr.nel == 0) {
+ if(t->mhdr.len == 0) {
// already an empty interface
*(Eface*)ret = *(Eface*)x;
return;
static int32 argc;
static uint8** argv;
-Array os·Args;
-Array os·Envs;
+Slice os·Args;
+Slice os·Envs;
void
args(int32 c, uint8 **v)
for(i=0; i<argc; i++)
gargv[i] = gostring(argv[i]);
os·Args.array = (byte*)gargv;
- os·Args.nel = argc;
+ os·Args.len = argc;
os·Args.cap = argc;
for(i=0; i<envc; i++)
genvv[i] = gostring(argv[argc+1+i]);
os·Envs.array = (byte*)genvv;
- os·Envs.nel = envc;
+ os·Envs.len = envc;
os·Envs.cap = envc;
}
bs = (byte*)s;
len = findnull(bs);
envv = (String*)os·Envs.array;
- envc = os·Envs.nel;
+ envc = os·Envs.len;
for(i=0; i<envc; i++){
if(envv[i].len <= len)
continue;
typedef uint8 bool;
typedef uint8 byte;
typedef struct Alg Alg;
-typedef struct Array Array;
typedef struct Func Func;
typedef struct G G;
typedef struct Gobuf Gobuf;
typedef struct M M;
typedef struct Mem Mem;
typedef union Note Note;
+typedef struct Slice Slice;
typedef struct Stktop Stktop;
typedef struct String String;
typedef struct Usema Usema;
void* data;
};
-struct Array
+struct Slice
{ // must not move anything
byte* array; // actual data
- uint32 nel; // number of elements
+ uint32 len; // number of elements
uint32 cap; // allocated number of elements
};
struct Gobuf
String src; // src file name
uint64 entry; // entry pc
int64 frame; // stack frame size
- Array pcln; // pc/ln tab for this func
+ Slice pcln; // pc/ln tab for this func
int64 pc0; // starting pc, ln for table
int32 ln0;
int32 args; // number of 32-bit in/out args
#define sys_memclr sys·memclr
#define sys_getcallerpc sys·getcallerpc
#define sys_mmap sys·mmap
-#define sys_printarray sys·printarray
+#define sys_printslice sys·printslice
#define sys_printbool sys·printbool
#define sys_printfloat sys·printfloat
#define sys_printhex sys·printhex
void sys_printpointer(void*);
void sys_printuint(uint64);
void sys_printhex(uint64);
-void sys_printarray(Array);
+void sys_printslice(Slice);
/*
* wrapped for go users
static int32 debug = 0;
-// newarray(nel int, cap int, width int) (ary []any);
+// makeslice(nel int, cap int, width int) (ary []any);
void
-sys·newarray(uint32 nel, uint32 cap, uint32 width, Array ret)
+sys·makeslice(uint32 nel, uint32 cap, uint32 width, Slice ret)
{
uint64 size;
cap = nel;
size = cap*width;
- ret.nel = nel;
+ ret.len = nel;
ret.cap = cap;
ret.array = mal(size);
FLUSH(&ret);
if(debug) {
- prints("newarray: nel=");
+ prints("makeslice: nel=");
sys·printint(nel);
prints("; cap=");
sys·printint(cap);
prints("; width=");
sys·printint(width);
prints("; ret=");
- sys·printarray(ret);
+ sys·printslice(ret);
prints("\n");
}
}
throw("array slice");
}
-// arraysliced(old []any, lb int, hb int, width int) (ary []any);
+// sliceslice(old []any, lb int, hb int, width int) (ary []any);
void
-sys·arraysliced(Array old, uint32 lb, uint32 hb, uint32 width, Array ret)
+sys·sliceslice(Slice old, uint32 lb, uint32 hb, uint32 width, Slice ret)
{
if(hb > old.cap || lb > hb) {
if(debug) {
- prints("sys·arraysliced: old=");
- sys·printarray(old);
+ prints("sys·sliceslice: old=");
+ sys·printslice(old);
prints("; lb=");
sys·printint(lb);
prints("; hb=");
prints("\n");
prints("oldarray: nel=");
- sys·printint(old.nel);
+ sys·printint(old.len);
prints("; cap=");
sys·printint(old.cap);
prints("\n");
}
// new array is inside old array
- ret.nel = hb-lb;
+ ret.len = hb-lb;
ret.cap = old.cap - lb;
ret.array = old.array + lb*width;
FLUSH(&ret);
if(debug) {
- prints("sys·arraysliced: old=");
- sys·printarray(old);
+ prints("sys·sliceslice: old=");
+ sys·printslice(old);
prints("; lb=");
sys·printint(lb);
prints("; hb=");
prints("; width=");
sys·printint(width);
prints("; ret=");
- sys·printarray(ret);
+ sys·printslice(ret);
prints("\n");
}
}
-// arrayslices(old *any, nel int, lb int, hb int, width int) (ary []any);
+// slicearray(old *any, nel int, lb int, hb int, width int) (ary []any);
void
-sys·arrayslices(byte* old, uint32 nel, uint32 lb, uint32 hb, uint32 width, Array ret)
+sys·slicearray(byte* old, uint32 nel, uint32 lb, uint32 hb, uint32 width, Slice ret)
{
if(hb > nel || lb > hb) {
if(debug) {
- prints("sys·arrayslices: old=");
+ prints("sys·slicearray: old=");
sys·printpointer(old);
prints("; nel=");
sys·printint(nel);
}
// new array is inside old array
- ret.nel = hb-lb;
+ ret.len = hb-lb;
ret.cap = nel-lb;
ret.array = old + lb*width;
FLUSH(&ret);
if(debug) {
- prints("sys·arrayslices: old=");
+ prints("sys·slicearray: old=");
sys·printpointer(old);
prints("; nel=");
sys·printint(nel);
prints("; width=");
sys·printint(width);
prints("; ret=");
- sys·printarray(ret);
+ sys·printslice(ret);
prints("\n");
}
}
-// arrays2d(old *any, nel int) (ary []any)
+// arraytoslice(old *any, nel int) (ary []any)
void
-sys·arrays2d(byte* old, uint32 nel, Array ret)
+sys·arraytoslice(byte* old, uint32 nel, Slice ret)
{
// new dope to old array
- ret.nel = nel;
+ ret.len = nel;
ret.cap = nel;
ret.array = old;
FLUSH(&ret);
if(debug) {
- prints("sys·arrays2d: old=");
+ prints("sys·slicearrayp: old=");
sys·printpointer(old);
prints("; ret=");
- sys·printarray(ret);
+ sys·printslice(ret);
prints("\n");
}
}
void
-sys·printarray(Array a)
+sys·printslice(Slice a)
{
prints("[");
- sys·printint(a.nel);
+ sys·printint(a.len);
prints("/");
sys·printint(a.cap);
prints("]");
s.len = runetochar(s.str, v);
}
-func arraystring(b Array) (s String) {
- s = gostringsize(b.nel);
+func slicebytetostring(b Slice) (s String) {
+ s = gostringsize(b.len);
mcpy(s.str, b.array, s.len);
}
-func arraystringi(b Array) (s String) {
+func sliceinttostring(b Slice) (s String) {
int32 siz1, siz2, i;
int32 *a;
byte dum[8];
a = (int32*)b.array;
siz1 = 0;
- for(i=0; i<b.nel; i++) {
+ for(i=0; i<b.len; i++) {
siz1 += runetochar(dum, a[i]);
}
s = gostringsize(siz1+4);
siz2 = 0;
- for(i=0; i<b.nel; i++) {
+ for(i=0; i<b.len; i++) {
// check for race
if(siz2 >= siz1)
break;
// Return a pointer to a byte array containing the symbol table segment.
void
-sys·symdat(Array *symtab, Array *pclntab)
+sys·symdat(Slice *symtab, Slice *pclntab)
{
- Array *a;
+ Slice *a;
int32 *v;
v = SYMCOUNTS;
a = mal(sizeof *a);
- a->nel = v[0];
- a->cap = a->nel;
+ a->len = v[0];
+ a->cap = a->len;
a->array = SYMDATA;
symtab = a;
FLUSH(&symtab);
a = mal(sizeof *a);
- a->nel = v[1];
- a->cap = a->nel;
+ a->len = v[1];
+ a->cap = a->len;
a->array = SYMDATA + v[0];
pclntab = a;
FLUSH(&pclntab);
line = 0;
for(; p < ep; p++) {
if(f < ef && pc > (f+1)->entry) {
- f->pcln.nel = p - f->pcln.array;
- f->pcln.cap = f->pcln.nel;
+ f->pcln.len = p - f->pcln.array;
+ f->pcln.cap = f->pcln.len;
f++;
f->pcln.array = p;
f->pc0 = pc;
pc += PcQuant;
}
if(f < ef) {
- f->pcln.nel = p - f->pcln.array;
- f->pcln.cap = f->pcln.nel;
+ f->pcln.len = p - f->pcln.array;
+ f->pcln.cap = f->pcln.len;
}
}
int32 line;
p = f->pcln.array;
- ep = p + f->pcln.nel;
+ ep = p + f->pcln.len;
pc = f->pc0;
line = f->ln0;
for(; p < ep && pc <= targetpc; p++) {
{
String *name;
String *pkgPath;
- Array mhdr;
+ Slice mhdr;
Method m[];
};
struct InterfaceType
{
Type;
- Array mhdr;
+ Slice mhdr;
IMethod m[];
};