void syscall·NewCallback(Eface fn, uintptr code) { #line 39 "d:\Go1.1\src\pkg\runtime\syscall_windows.goc" code = (uintptr)runtime·compilecallback(fn, true); FLUSH(&code); }
void ·_Cfunc_CString(String s, int8 *p) { p = runtime·cmalloc(s.len+1); runtime·memmove((byte*)p, s.str, s.len); p[s.len] = 0; FLUSH(&p); }
void runtime·convI2E(Iface i, Eface ret) { ret.type = 0; ret.data = 0; FLUSH(&ret); #line 310 "/home/14/ren/source/golang/go/src/pkg/runtime/iface.goc" Itab *tab; ret.data = i.data; if((tab = i.tab) == nil) ret.type = nil; else ret.type = tab->type; FLUSH(&ret); }
void syscall·NewCallbackCDecl(Eface fn, uintptr code) { #line 43 "syscall_windows.goc" code = (uintptr)runtime·compilecallback(fn, false); FLUSH(&code); }
void runtime·convI2E(Iface i, Eface ret) { ret.type = 0; ret.data = 0; FLUSH(&ret); #line 325 "/tmp/makerelease197226928/go/src/pkg/runtime/iface.goc" Itab *tab; ret.data = i.data; if((tab = i.tab) == nil) ret.type = nil; else ret.type = tab->type; FLUSH(&ret); }
void net·runtime_pollReset(PollDesc* pd, intgo mode, intgo err) { err = 0; FLUSH(&err); #line 129 "/home/14/ren/source/golang/go/src/pkg/runtime/netpoll.goc" err = checkerr(pd, mode); if(err) goto ret; if(mode == 'r') pd->rg = nil; else if(mode == 'w') pd->wg = nil; ret: FLUSH(&err); }
void runtime·copy(Slice to, Slice fm, uintptr width, intgo ret) { ret = 0; FLUSH(&ret); #line 139 "/home/14/ren/source/golang/go/src/pkg/runtime/slice.goc" void *pc; if(fm.len == 0 || to.len == 0 || width == 0) { ret = 0; goto out; } ret = fm.len; if(to.len < ret) ret = to.len; if(raceenabled) { pc = runtime·getcallerpc(&to); runtime·racewriterangepc(to.array, ret*width, pc, runtime·copy); runtime·racereadrangepc(fm.array, ret*width, pc, runtime·copy); } if(ret == 1 && width == 1) { // common case worth about 2x to do here *to.array = *fm.array; // known to be a byte pointer } else { runtime·memmove(to.array, fm.array, ret*width); } out: if(debug) { runtime·prints("main·copy: to="); runtime·printslice(to); runtime·prints("; fm="); runtime·printslice(fm); runtime·prints("; width="); runtime·printint(width); runtime·prints("; ret="); runtime·printint(ret); runtime·prints("\n"); } FLUSH(&ret); }
void runtime·copy(Slice to, Slice fm, uintptr width, intgo ret) { ret = 0; FLUSH(&ret); #line 135 "C:\Users\ADMINI~1\AppData\Local\Temp\2\makerelease686069423\go\src\pkg\runtime\slice.goc" void *pc; if(fm.len == 0 || to.len == 0 || width == 0) { ret = 0; goto out; } ret = fm.len; if(to.len < ret) ret = to.len; if(raceenabled) { pc = runtime·getcallerpc(&to); runtime·racewriterangepc(to.array, ret*width, pc, runtime·copy); runtime·racereadrangepc(fm.array, ret*width, pc, runtime·copy); } if(ret == 1 && width == 1) { // common case worth about 2x to do here *to.array = *fm.array; // known to be a byte pointer } else { runtime·memmove(to.array, fm.array, ret*width); } out: if(debug) { runtime·prints("main·copy: to="); runtime·printslice(to); runtime·prints("; fm="); runtime·printslice(fm); runtime·prints("; width="); runtime·printint(width); runtime·prints("; ret="); runtime·printint(ret); runtime·prints("\n"); } FLUSH(&ret); }
void runtime·getgoroot(String out) { byte *p; p = runtime·getenv("GOROOT"); out = runtime·gostringnocopy(p); FLUSH(&out); }
// func ifaceI2E2(typ *byte, iface any) (ret any, ok bool) void runtime·assertI2E2(InterfaceType* inter, Iface i, Eface ret, bool ok) { Itab *tab; USED(inter); tab = i.tab; if(tab == nil) { ret.type = nil; ok = 0; } else { ret.type = tab->type; ok = 1; } ret.data = i.data; FLUSH(&ret); FLUSH(&ok); }
void runtime·typ2Itab(Type* t, InterfaceType* inter, Itab** cache, Itab* tab) { #line 172 "/home/pi/go_build/hg/go/src/pkg/runtime/iface.goc" tab = itab(inter, t, 0); runtime·atomicstorep(cache, tab); FLUSH(&tab); }
// For reflect // func chancap(c chan) (cap int32) void reflect·chancap(Hchan *c, int32 cap) { if(c == nil) cap = 0; else cap = c->dataqsiz; FLUSH(&cap); }
void runtime·convT2E(Type* t, byte* elem, Eface ret) { #line 191 "/home/pi/go_build/hg/go/src/pkg/runtime/iface.goc" ret.type = t; copyin(t, elem, &ret.data); FLUSH(&ret); }
void runtime·eqstring(String s1, String s2, bool v) { v = 0; FLUSH(&v); #line 209 "/home/14/ren/source/golang/go/src/pkg/runtime/string.goc" if(s1.len != s2.len) { v = false; return; } if(s1.str == s2.str) { v = true; return; } v = runtime·memeq(s1.str, s2.str, s1.len); FLUSH(&v); }
// For reflect // func chanlen(c chan) (len int32) void reflect·chanlen(Hchan *c, int32 len) { if(c == nil) len = 0; else len = c->qcount; FLUSH(&len); }
void runtime·slicebytetostring(Slice b, String s) { s.str = 0; s.len = 0; FLUSH(&s); #line 286 "/home/14/ren/source/golang/go/src/pkg/runtime/string.goc" void *pc; if(raceenabled) { pc = runtime·getcallerpc(&b); runtime·racereadrangepc(b.array, b.len, pc, runtime·slicebytetostring); } s = gostringsize(b.len); runtime·memmove(s.str, b.array, s.len); FLUSH(&s); }
// func ifaceI2I2(sigi *byte, iface any) (ret any, ok bool) void runtime·assertI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok) { Itab *tab; tab = i.tab; if(tab != nil && (tab->inter == inter || (tab = itab(inter, tab->type, 1)) != nil)) { ret.data = i.data; ret.tab = tab; ok = 1; } else { ret.data = 0; ret.tab = 0; ok = 0; } FLUSH(&ret); FLUSH(&ok); }
void runtime·slicebytetostring(Slice b, String s) { #line 3587 "C:\Go\src\pkg\runtime\string.goc" s = gostringsize(b.len); runtime·memmove(s.str, b.array, s.len); FLUSH(&s); }
/* Writes verbose message to stderr if desired and then returns. */ void AppVerbose( const char *fmt, /* Format control */ ... ) /* Optional arguments */ { va_list marker; /* parameter list of variable length */ if(appOutput == APP_NOOUT) return; /* no progress message desired */ /* Let marker point to 1st unnamed argument */ va_start(marker, VA_START_ARG(fmt)); (void)vfprintf(stderr, fmt, marker); va_end(marker); /* clean up */ FLUSH(stderr); FLUSH(stdout); return; }
void runtime·convT2I(Type* t, InterfaceType* inter, Itab** cache, byte* elem, Iface ret) { ret.tab = 0; ret.data = 0; FLUSH(&ret); #line 192 "/home/14/ren/source/golang/go/src/pkg/runtime/iface.goc" Itab *tab; tab = runtime·atomicloadp(cache); if(!tab) { tab = itab(inter, t, 0); runtime·atomicstorep(cache, tab); } ret.tab = tab; copyin(t, elem, &ret.data); FLUSH(&ret); }
void runtime·assertE2I2(InterfaceType* inter, Eface e, Iface ret, bool ok) { #line 422 "/home/pi/go_build/hg/go/src/pkg/runtime/iface.goc" if(e.type == nil) { ok = 0; ret.data = nil; ret.tab = nil; } else if((ret.tab = itab(inter, e.type, 1)) == nil) { ok = 0; ret.data = nil; } else { ok = 1; ret.data = e.data; } FLUSH(&ret); FLUSH(&ok); }
void client_write_move(remote_process_client *client, const struct ct_move *move) { WRITE_BYTE(MSG_MOVE_MESSAGE); WRITE_BYTE(1); WRITE_BYTE((signed char)move->action); WRITE_BYTE((signed char)move->direction); WRITE_INT32(move->position.x); WRITE_INT32(move->position.y); FLUSH(); }
void syscall·loadlibrary(uint16* filename, uintptr handle, uintptr err) { #line 3700 "C:\Go\src\pkg\runtime\syscall_windows.goc" WinCall c; c.fn = runtime·LoadLibrary; c.n = 1; c.args = &filename; runtime·cgocall(runtime·asmstdcall, &c); handle = c.r1; if(handle == 0) err = c.err; else err = 0; FLUSH(&handle); FLUSH(&err); }
void runtime·convI2I(InterfaceType* inter, Iface i, Iface ret) { ret.tab = 0; ret.data = 0; FLUSH(&ret); #line 351 "/home/14/ren/source/golang/go/src/pkg/runtime/iface.goc" Itab *tab; ret.data = i.data; if((tab = i.tab) == nil) ret.tab = nil; else if(tab->inter == inter) ret.tab = tab; else ret.tab = itab(inter, tab->type, 0); FLUSH(&ret); }
void reflect·typelinks(Slice ret) { extern Type *typelink[], *etypelink[]; static int32 first = 1; ret.array = (byte*)typelink; ret.len = etypelink - typelink; ret.cap = ret.len; FLUSH(&ret); }
void runtime·intstring(int64 v, String s) { #line 244 "/home/pi/go_build/go/src/pkg/runtime/string.goc" s = gostringsize(8); s.len = runtime·runetochar(s.str, v); s.str[s.len] = 0; FLUSH(&s); }
void runtime·typ2Itab(Type *t, InterfaceType *inter, Itab **cache, Itab *ret) { Itab *tab; tab = itab(inter, t, 0); runtime·atomicstorep(cache, tab); ret = tab; FLUSH(&ret); }
void runtime·intstring(int64 v, String s) { #line 3581 "C:\Go\src\pkg\runtime\string.goc" s = gostringsize(8); s.len = runtime·runetochar(s.str, v); s.str[s.len] = 0; FLUSH(&s); }
void runtime·NumCgoCall(int64 ret) { M *m; ret = 0; for(m=runtime·atomicloadp(&runtime·allm); m; m=m->alllink) ret += m->ncgocall; FLUSH(&ret); }
void Log::lprintf( char *format, ... ) { va_list vl; va_start(vl, format); Log * log = getLog(); log->myMsg[MSG_MAX-1] = 0; vsnprintf(log->myMsg, MSG_MAX-1, format, vl); PRINTF(log->myMsg); FLUSH(); }