mirror of
https://github.com/golang/go
synced 2024-11-11 21:50:21 -07:00
rearrange tree to reflect design based on $GOROOT $GOOS $GOARCH
SVN=121291
This commit is contained in:
Rob Pike
parent
f4ccabdea6
commit
5624e34494
@ -1,595 +0,0 @@
|
||||
// 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.
|
||||
|
||||
#include "runtime.h"
|
||||
|
||||
int32 debug = 0;
|
||||
|
||||
void
|
||||
sys_printbool(bool v)
|
||||
{
|
||||
if(v) {
|
||||
sys_write(1, (byte*)"true", 4);
|
||||
return;
|
||||
}
|
||||
sys_write(1, (byte*)"false", 5);
|
||||
}
|
||||
|
||||
void
|
||||
sys_printfloat(float64 v)
|
||||
{
|
||||
sys_write(1, "printfloat", 10);
|
||||
}
|
||||
|
||||
void
|
||||
sys_printint(int64 v)
|
||||
{
|
||||
byte buf[100];
|
||||
int32 i, s;
|
||||
|
||||
s = 0;
|
||||
if(v < 0) {
|
||||
v = -v;
|
||||
s = 1;
|
||||
if(v < 0) {
|
||||
sys_write(1, (byte*)"-oo", 3);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
for(i=nelem(buf)-1; i>0; i--) {
|
||||
buf[i] = v%10 + '0';
|
||||
if(v < 10)
|
||||
break;
|
||||
v = v/10;
|
||||
}
|
||||
if(s) {
|
||||
i--;
|
||||
buf[i] = '-';
|
||||
}
|
||||
sys_write(1, buf+i, nelem(buf)-i);
|
||||
}
|
||||
|
||||
void
|
||||
sys_printpointer(void *p)
|
||||
{
|
||||
uint64 v;
|
||||
byte buf[100];
|
||||
int32 i;
|
||||
|
||||
v = (int64)p;
|
||||
for(i=nelem(buf)-1; i>0; i--) {
|
||||
buf[i] = v%16 + '0';
|
||||
if(buf[i] > '9')
|
||||
buf[i] += 'a'-'0'-10;
|
||||
if(v < 16)
|
||||
break;
|
||||
v = v/16;
|
||||
}
|
||||
sys_write(1, buf+i, nelem(buf)-i);
|
||||
}
|
||||
|
||||
void
|
||||
sys_panicl(int32 lno)
|
||||
{
|
||||
prints("\npanic on line ");
|
||||
sys_printint(lno);
|
||||
prints("\n");
|
||||
*(int32*)0 = 0;
|
||||
}
|
||||
|
||||
void
|
||||
sys_printstring(string v)
|
||||
{
|
||||
sys_write(1, v->str, v->len);
|
||||
}
|
||||
|
||||
int32
|
||||
strlen(int8 *s)
|
||||
{
|
||||
int32 l;
|
||||
|
||||
for(l=0; s[l]!=0; l++)
|
||||
;
|
||||
return l;
|
||||
}
|
||||
|
||||
void
|
||||
prints(int8 *s)
|
||||
{
|
||||
sys_write(1, s, strlen(s));
|
||||
}
|
||||
|
||||
dump(byte *p, int32 n)
|
||||
{
|
||||
uint32 v;
|
||||
int32 i;
|
||||
|
||||
for(i=0; i<n; i++) {
|
||||
sys_printpointer((byte*)(p[i]>>4));
|
||||
sys_printpointer((byte*)(p[i]&0xf));
|
||||
if((i&15) == 15)
|
||||
prints("\n");
|
||||
else
|
||||
prints(" ");
|
||||
}
|
||||
if(n & 15)
|
||||
prints("\n");
|
||||
}
|
||||
|
||||
static uint8* hunk;
|
||||
static uint32 nhunk;
|
||||
static uint64 nmmap;
|
||||
static uint64 nmal;
|
||||
enum
|
||||
{
|
||||
NHUNK = 20<<20,
|
||||
|
||||
PROT_NONE = 0x00,
|
||||
PROT_READ = 0x01,
|
||||
PROT_WRITE = 0x02,
|
||||
PROT_EXEC = 0x04,
|
||||
|
||||
MAP_FILE = 0x0000,
|
||||
MAP_SHARED = 0x0001,
|
||||
MAP_PRIVATE = 0x0002,
|
||||
MAP_FIXED = 0x0010,
|
||||
MAP_ANON = 0x1000,
|
||||
};
|
||||
|
||||
static void
|
||||
throw(int8 *s)
|
||||
{
|
||||
prints("throw: ");
|
||||
prints(s);
|
||||
prints("\n");
|
||||
sys_exit(1);
|
||||
}
|
||||
|
||||
static void
|
||||
mcpy(byte *t, byte *f, uint32 n)
|
||||
{
|
||||
while(n > 0) {
|
||||
*t = *f;
|
||||
t++;
|
||||
f++;
|
||||
n--;
|
||||
}
|
||||
}
|
||||
|
||||
static byte*
|
||||
brk(uint32 n)
|
||||
{
|
||||
byte* v;
|
||||
|
||||
v = sys_mmap(nil, NHUNK, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
|
||||
sys_memclr(v, n);
|
||||
nmmap += n;
|
||||
return v;
|
||||
}
|
||||
|
||||
static void*
|
||||
mal(uint32 n)
|
||||
{
|
||||
byte* v;
|
||||
|
||||
// round to keep everything 64-bit alligned
|
||||
while(n & 7)
|
||||
n++;
|
||||
|
||||
nmal += n;
|
||||
|
||||
// do we have enough in contiguous hunk
|
||||
if(n > nhunk) {
|
||||
|
||||
// if it is big allocate it separately
|
||||
if(n > NHUNK)
|
||||
return brk(n);
|
||||
|
||||
// allocate a new contiguous hunk
|
||||
hunk = brk(NHUNK);
|
||||
nhunk = NHUNK;
|
||||
}
|
||||
|
||||
// allocate from the contiguous hunk
|
||||
v = hunk;
|
||||
hunk += n;
|
||||
nhunk -= n;
|
||||
return v;
|
||||
}
|
||||
|
||||
void
|
||||
sys_mal(uint32 n, uint8 *ret)
|
||||
{
|
||||
ret = mal(n);
|
||||
FLUSH(&ret);
|
||||
}
|
||||
|
||||
void
|
||||
sys_catstring(string s1, string s2, string s3)
|
||||
{
|
||||
uint32 l;
|
||||
|
||||
if(s1->len == 0) {
|
||||
s3 = s2;
|
||||
goto out;
|
||||
}
|
||||
if(s2->len == 0) {
|
||||
s3 = s1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
l = s1->len + s2->len;
|
||||
|
||||
s3 = mal(sizeof(s3->len)+l);
|
||||
s3->len = l;
|
||||
mcpy(s3->str, s1->str, s1->len);
|
||||
mcpy(s3->str+s1->len, s2->str, s2->len);
|
||||
|
||||
out:
|
||||
FLUSH(&s3);
|
||||
}
|
||||
|
||||
void
|
||||
sys_cmpstring(string s1, string s2, int32 v)
|
||||
{
|
||||
uint32 i, l;
|
||||
byte c1, c2;
|
||||
|
||||
l = s1->len;
|
||||
if(s2->len < l)
|
||||
l = s2->len;
|
||||
for(i=0; i<l; i++) {
|
||||
c1 = s1->str[i];
|
||||
c2 = s2->str[i];
|
||||
if(c1 < c2) {
|
||||
v = -1;
|
||||
goto out;
|
||||
}
|
||||
if(c1 > c2) {
|
||||
v = +1;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
if(s1->len < s2->len) {
|
||||
v = -1;
|
||||
goto out;
|
||||
}
|
||||
if(s1->len > s2->len) {
|
||||
v = +1;
|
||||
goto out;
|
||||
}
|
||||
v = 0;
|
||||
|
||||
out:
|
||||
FLUSH(&v);
|
||||
}
|
||||
|
||||
static int32
|
||||
strcmp(byte *s1, byte *s2)
|
||||
{
|
||||
uint32 i;
|
||||
byte c1, c2;
|
||||
|
||||
for(i=0;; i++) {
|
||||
c1 = s1[i];
|
||||
c2 = s2[i];
|
||||
if(c1 < c2)
|
||||
return -1;
|
||||
if(c1 > c2)
|
||||
return +1;
|
||||
if(c1 == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
prbounds(int8* s, int32 a, int32 b, int32 c)
|
||||
{
|
||||
int32 i;
|
||||
|
||||
prints(s);
|
||||
prints(" ");
|
||||
sys_printint(a);
|
||||
prints("<");
|
||||
sys_printint(b);
|
||||
prints(">");
|
||||
sys_printint(c);
|
||||
prints("\n");
|
||||
throw("bounds");
|
||||
}
|
||||
|
||||
void
|
||||
sys_slicestring(string si, int32 lindex, int32 hindex, string so)
|
||||
{
|
||||
string s, str;
|
||||
int32 l;
|
||||
|
||||
if(lindex < 0 || lindex > si->len ||
|
||||
hindex < lindex || hindex > si->len)
|
||||
prbounds("slice", lindex, si->len, hindex);
|
||||
|
||||
l = hindex-lindex;
|
||||
so = mal(sizeof(so->len)+l);
|
||||
so->len = l;
|
||||
mcpy(so->str, si->str+lindex, l);
|
||||
FLUSH(&so);
|
||||
}
|
||||
|
||||
void
|
||||
sys_indexstring(string s, int32 i, byte b)
|
||||
{
|
||||
if(i < 0 || i >= s->len)
|
||||
prbounds("index", 0, i, s->len);
|
||||
|
||||
b = s->str[i];
|
||||
FLUSH(&b);
|
||||
}
|
||||
|
||||
/*
|
||||
* this is the plan9 runetochar
|
||||
* extended for 36 bits in 7 bytes
|
||||
* note that it truncates to 32 bits
|
||||
* through the argument passing.
|
||||
*/
|
||||
static int32
|
||||
runetochar(byte *str, uint32 c)
|
||||
{
|
||||
int32 i, n;
|
||||
uint32 mask, mark;
|
||||
|
||||
/*
|
||||
* one character in 7 bits
|
||||
*/
|
||||
if(c <= 0x07FUL) {
|
||||
str[0] = c;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* every new character picks up 5 bits
|
||||
* one less in the first byte and
|
||||
* six more in an extension byte
|
||||
*/
|
||||
mask = 0x7ffUL;
|
||||
mark = 0xC0UL;
|
||||
for(n=1;; n++) {
|
||||
if(c <= mask)
|
||||
break;
|
||||
mask = (mask<<5) | 0x1fUL;
|
||||
mark = (mark>>1) | 0x80UL;
|
||||
}
|
||||
|
||||
/*
|
||||
* lay down the bytes backwards
|
||||
* n is the number of extension bytes
|
||||
* mask is the max codepoint
|
||||
* mark is the zeroth byte indicator
|
||||
*/
|
||||
for(i=n; i>0; i--) {
|
||||
str[i] = 0x80UL | (c&0x3fUL);
|
||||
c >>= 6;
|
||||
}
|
||||
|
||||
str[0] = mark|c;
|
||||
return n+1;
|
||||
}
|
||||
|
||||
void
|
||||
sys_intstring(int64 v, string s)
|
||||
{
|
||||
int32 l;
|
||||
|
||||
s = mal(sizeof(s->len)+8);
|
||||
s->len = runetochar(s->str, v);
|
||||
FLUSH(&s);
|
||||
}
|
||||
|
||||
void
|
||||
sys_byteastring(byte *a, int32 l, string s)
|
||||
{
|
||||
s = mal(sizeof(s->len)+l);
|
||||
s->len = l;
|
||||
mcpy(s->str, a, l);
|
||||
FLUSH(&s);
|
||||
}
|
||||
|
||||
static Map* hash[1009];
|
||||
|
||||
static Map*
|
||||
hashmap(Sigi *si, Sigs *ss)
|
||||
{
|
||||
int32 ns, ni;
|
||||
uint32 ihash, h;
|
||||
byte *sname, *iname;
|
||||
Map *m;
|
||||
|
||||
h = ((uint32)si + (uint32)ss) % nelem(hash);
|
||||
for(m=hash[h]; m!=nil; m=m->link) {
|
||||
if(m->si == si && m->ss == ss) {
|
||||
if(m->bad) {
|
||||
throw("bad hashmap");
|
||||
m = nil;
|
||||
}
|
||||
// prints("old hashmap\n");
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
ni = si[0].offset; // first word has size
|
||||
m = mal(sizeof(*m) + ni*sizeof(m->fun[0]));
|
||||
m->si = si;
|
||||
m->ss = ss;
|
||||
|
||||
ni = 1; // skip first word
|
||||
ns = 0;
|
||||
|
||||
loop1:
|
||||
// pick up next name from
|
||||
// interface signature
|
||||
iname = si[ni].name;
|
||||
if(iname == nil) {
|
||||
m->link = hash[h];
|
||||
hash[h] = m;
|
||||
// prints("new hashmap\n");
|
||||
return m;
|
||||
}
|
||||
ihash = si[ni].hash;
|
||||
|
||||
loop2:
|
||||
// pick up and comapre next name
|
||||
// from structure signature
|
||||
sname = ss[ns].name;
|
||||
if(sname == nil) {
|
||||
prints((int8*)iname);
|
||||
prints(": ");
|
||||
throw("hashmap: failed to find method");
|
||||
m->bad = 1;
|
||||
m->link = hash[h];
|
||||
hash[h] = m;
|
||||
return nil;
|
||||
}
|
||||
if(ihash != ss[ns].hash ||
|
||||
strcmp(sname, iname) != 0) {
|
||||
ns++;
|
||||
goto loop2;
|
||||
}
|
||||
|
||||
m->fun[si[ni].offset] = ss[ns].fun;
|
||||
ni++;
|
||||
goto loop1;
|
||||
}
|
||||
|
||||
void
|
||||
sys_ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
|
||||
{
|
||||
|
||||
if(debug) {
|
||||
prints("s2i sigi=");
|
||||
sys_printpointer(si);
|
||||
prints(" sigs=");
|
||||
sys_printpointer(ss);
|
||||
prints(" s=");
|
||||
sys_printpointer(s);
|
||||
}
|
||||
|
||||
if(s == nil) {
|
||||
throw("ifaces2i: nil pointer");
|
||||
m = nil;
|
||||
FLUSH(&m);
|
||||
return;
|
||||
}
|
||||
|
||||
m = hashmap(si, ss);
|
||||
|
||||
if(debug) {
|
||||
prints(" returning m=");
|
||||
sys_printpointer(m);
|
||||
prints(" s=");
|
||||
sys_printpointer(s);
|
||||
prints("\n");
|
||||
dump((byte*)m, 64);
|
||||
}
|
||||
|
||||
FLUSH(&m);
|
||||
}
|
||||
|
||||
void
|
||||
sys_ifacei2i(Sigi *si, Map *m, void *s)
|
||||
{
|
||||
|
||||
if(debug) {
|
||||
prints("i2i sigi=");
|
||||
sys_printpointer(si);
|
||||
prints(" m=");
|
||||
sys_printpointer(m);
|
||||
prints(" s=");
|
||||
sys_printpointer(s);
|
||||
}
|
||||
|
||||
if(m == nil) {
|
||||
throw("ifacei2i: nil map");
|
||||
s = nil;
|
||||
FLUSH(&s);
|
||||
return;
|
||||
}
|
||||
|
||||
if(m->si == nil) {
|
||||
throw("ifacei2i: nil pointer");
|
||||
return;
|
||||
}
|
||||
|
||||
if(m->si != si) {
|
||||
m = hashmap(si, m->ss);
|
||||
FLUSH(&m);
|
||||
}
|
||||
|
||||
if(debug) {
|
||||
prints(" returning m=");
|
||||
sys_printpointer(m);
|
||||
prints(" s=");
|
||||
sys_printpointer(s);
|
||||
prints("\n");
|
||||
dump((byte*)m, 64);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
sys_ifacei2s(Sigs *ss, Map *m, void *s)
|
||||
{
|
||||
|
||||
if(debug) {
|
||||
prints("i2s m=");
|
||||
sys_printpointer(m);
|
||||
prints(" s=");
|
||||
sys_printpointer(s);
|
||||
prints("\n");
|
||||
}
|
||||
|
||||
if(m == nil) {
|
||||
throw("ifacei2s: nil map");
|
||||
s = nil;
|
||||
FLUSH(&s);
|
||||
return;
|
||||
}
|
||||
|
||||
if(m->ss != ss) {
|
||||
dump((byte*)m, 64);
|
||||
throw("ifacei2s: wrong pointer");
|
||||
s = nil;
|
||||
FLUSH(&s);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
check(void)
|
||||
{
|
||||
int8 a;
|
||||
uint8 b;
|
||||
int16 c;
|
||||
uint16 d;
|
||||
int32 e;
|
||||
uint32 f;
|
||||
int64 g;
|
||||
uint64 h;
|
||||
float32 i;
|
||||
float64 j;
|
||||
void* k;
|
||||
uint16* l;
|
||||
|
||||
if(sizeof(a) != 1) throw("bad a");
|
||||
if(sizeof(b) != 1) throw("bad b");
|
||||
if(sizeof(c) != 2) throw("bad c");
|
||||
if(sizeof(d) != 2) throw("bad d");
|
||||
if(sizeof(e) != 4) throw("bad e");
|
||||
if(sizeof(f) != 4) throw("bad f");
|
||||
if(sizeof(g) != 8) throw("bad g");
|
||||
if(sizeof(h) != 8) throw("bad h");
|
||||
if(sizeof(i) != 4) throw("bad i");
|
||||
if(sizeof(j) != 8) throw("bad j");
|
||||
if(sizeof(k) != 8) throw("bad k");
|
||||
if(sizeof(l) != 8) throw("bad l");
|
||||
// prints(1"check ok\n");
|
||||
}
|
||||
@ -1,107 +0,0 @@
|
||||
// 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.
|
||||
|
||||
|
||||
/*
|
||||
* basic types
|
||||
*/
|
||||
typedef signed char int8;
|
||||
typedef unsigned char uint8;
|
||||
typedef signed short int16;
|
||||
typedef unsigned short uint16;
|
||||
typedef signed int int32;
|
||||
typedef unsigned int uint32;
|
||||
typedef signed long long int int64;
|
||||
typedef unsigned long long int uint64;
|
||||
typedef float float32;
|
||||
typedef double float64;
|
||||
|
||||
/*
|
||||
* get rid of C types
|
||||
*/
|
||||
#define unsigned XXunsigned
|
||||
#define signed XXsigned
|
||||
#define char XXchar
|
||||
#define short XXshort
|
||||
#define int XXint
|
||||
#define long XXlong
|
||||
#define float XXfloat
|
||||
#define double XXdouble
|
||||
|
||||
/*
|
||||
* defined types
|
||||
*/
|
||||
typedef uint8 bool;
|
||||
typedef uint8 byte;
|
||||
typedef struct
|
||||
{
|
||||
int32 len;
|
||||
byte str[1];
|
||||
} *string;
|
||||
typedef struct
|
||||
{
|
||||
byte* name;
|
||||
uint32 hash;
|
||||
void (*fun)(void);
|
||||
} Sigs;
|
||||
typedef struct
|
||||
{
|
||||
byte* name;
|
||||
uint32 hash;
|
||||
uint32 offset;
|
||||
} Sigi;
|
||||
typedef struct Map Map;
|
||||
struct Map
|
||||
{
|
||||
Sigi* si;
|
||||
Sigs* ss;
|
||||
Map* link;
|
||||
int32 bad;
|
||||
int32 unused;
|
||||
void (*fun[])(void);
|
||||
};
|
||||
|
||||
/*
|
||||
* defined constants
|
||||
*/
|
||||
enum
|
||||
{
|
||||
true = 1,
|
||||
false = 0,
|
||||
};
|
||||
|
||||
/*
|
||||
* defined macros
|
||||
* you need super-goru privilege
|
||||
* to add this list.
|
||||
*/
|
||||
#define nelem(x) (sizeof(x)/sizeof((x)[0]))
|
||||
#define nil ((void*)0)
|
||||
|
||||
/*
|
||||
* very low level
|
||||
*/
|
||||
void FLUSH(void*);
|
||||
void prints(int8*);
|
||||
void sys_exit(int32);
|
||||
void sys_write(int32, void*, int32);
|
||||
void sys_breakpoint(void);
|
||||
uint8* sys_mmap(byte*, uint32, int32, int32, int32, uint32);
|
||||
void sys_memclr(byte*, uint32);
|
||||
|
||||
/*
|
||||
* runtime
|
||||
*/
|
||||
void sys_printbool(bool);
|
||||
void sys_printfloat(float64);
|
||||
void sys_printint(int64);
|
||||
void sys_printstring(string);
|
||||
void sys_catstring(string, string, string);
|
||||
void sys_cmpstring(string, string, int32);
|
||||
void sys_slicestring(string, int32, int32, string);
|
||||
void sys_indexstring(string, int32, byte);
|
||||
void sys_intstring(int64, string);
|
||||
void sys_ifaces2i(Sigi*, Sigs*, Map*, void*);
|
||||
void sys_ifacei2i(Sigi*, Map*, void*);
|
||||
void sys_ifacei2s(Sigs*, Map*, void*);
|
||||
Loading…
Reference in New Issue
Block a user