middle dot as alpha package separator

SVN=124419

diff --git a/src/cmd/6g/gen.c b/src/cmd/6g/gen.c
index cbd2dd651bfb31589321fa91c27cf6281960f2d0..0bfd7be1667a61c2cf945c15e9a7ddaf86e9ce16 100644 (file)
--- a/src/cmd/6g/gen.c
+++ b/src/cmd/6g/gen.c
@@ -380,6 +380,7 @@ agen_inter(Node *n, Node *res)
                if(!n->left->addable) {
                        agen(n->left, &nodr);
                        gmove(&nodr, &nodo);
+                       dump("xxx", n->left);
                        fatal("agen_inter i2s");
                } else {
                        cgen(n->left, &nodo);

diff --git a/src/cmd/6g/obj.c b/src/cmd/6g/obj.c
index eae3d81216a163364816458d84d6abd39a9e8193..b3ae0c3bf0526e6841085cdf270175fa7dcc9a95 100644 (file)
--- a/src/cmd/6g/obj.c
+++ b/src/cmd/6g/obj.c
@@ -165,6 +165,13 @@ return;
        Bterm(bout);
 }
 
+Bputdot(Biobuf *b)
+{
+       // put out middle dot ·
+       Bputc(b, 0xc2);
+       Bputc(b, 0xb7);
+}
+
 void
 zname(Biobuf *b, Sym *s, int t)
 {
@@ -177,7 +184,7 @@ zname(Biobuf *b, Sym *s, int t)
 
        for(n=s->opackage; *n; n++)
                Bputc(b, *n);
-       Bputc(b, '_');
+       Bputdot(b);
        for(n=s->name; *n; n++)
                Bputc(b, *n);
        Bputc(b, 0);

diff --git a/src/cmd/cc/lexbody b/src/cmd/cc/lexbody
index f7ba6d0fcee37a43695c32bfa289b7d59e30d5e3..3a38e2ae9919ebd62b0e4fceb457c6417f29ad1c 100644 (file)
--- a/src/cmd/cc/lexbody
+++ b/src/cmd/cc/lexbody
@@ -232,6 +232,16 @@ lookup(void)
        return s;
 }
 
+int
+ISALPHA(int c)
+{
+       if(isalpha(c))
+               return 1;
+       if(c >= Runeself)
+               return 1;
+       return 0;
+}
+
 long
 yylex(void)
 {
@@ -259,7 +269,7 @@ l1:
                }
                goto l0;
        }
-       if(isalpha(c))
+       if(ISALPHA(c))
                goto talph;
        if(isdigit(c))
                goto tnum;
@@ -275,7 +285,7 @@ l1:
 
        case '.':
                c = GETC();
-               if(isalpha(c)) {
+               if(ISALPHA(c)) {
                        cp = symb;
                        *cp++ = '.';
                        goto aloop;
@@ -296,7 +306,7 @@ l1:
        aloop:
                *cp++ = c;
                c = GETC();
-               if(isalpha(c) || isdigit(c) || c == '_' || c == '$')
+               if(ISALPHA(c) || isdigit(c) || c == '_' || c == '$')
                        goto aloop;
                *cp = 0;
                peekc = c;

diff --git a/src/cmd/gc/walk.c b/src/cmd/gc/walk.c
index 6b3860d283b67b3883bb3090e95653233c5850e3..0c89ff138d2f1981bdd1944f43681bf174de6e3c 100644 (file)
--- a/src/cmd/gc/walk.c
+++ b/src/cmd/gc/walk.c
@@ -1789,6 +1789,14 @@ badt:
        return nl;
 }
 
+/*
+ * from ascompat[te]
+ * evaluating actual function arguments.
+ *     f(a,b)
+ * if there is exactly one function expr,
+ * then it is done first. otherwise must
+ * make temp variables
+ */
 Node*
 reorder1(Node *n)
 {
@@ -1796,15 +1804,6 @@ reorder1(Node *n)
        Node *l, *r, *f, *a, *g;
        int c, t;
 
-       /*
-        * from ascompat[te]
-        * evaluating actual function arguments.
-        *      f(a,b)
-        * if there is exactly one function expr,
-        * then it is done first. otherwise must
-        * make temp variables
-        */
-
        l = listfirst(&save, &n);
        c = 0;  // function calls
        t = 0;  // total parameters
@@ -1874,6 +1873,13 @@ more:
        goto loop2;
 }
 
+/*
+ * from ascompat[et]
+ *     a,b = f()
+ * return of a multi.
+ * there can be no function calls at all,
+ * or they will over-write the return values.
+ */
 Node*
 reorder2(Node *n)
 {
@@ -1881,14 +1887,6 @@ reorder2(Node *n)
        Node *l;
        int c;
 
-       /*
-        * from ascompat[et]
-        *      a,b = f()
-        * return of a multi.
-        * there can be no function calls at all,
-        * or they will over-write the return values.
-        */
-
        l = listfirst(&save, &n);
        c = 0;
 
@@ -1907,15 +1905,44 @@ loop1:
        goto loop1;
 }
 
+/*
+ * from ascompat[ee]
+ *     a,b = c,d
+ * simultaneous assignment. there can be
+ * later use of an earlier lvalue.
+ */
+int
+vmatch(Node *l, Node *r)
+{
+       dump("l", l);
+       dump("r", r);
+       return 0;
+}
+
 Node*
 reorder3(Node *n)
 {
-       /*
-        * from ascompat[ee]
-        *      a,b = c,d
-        * simultaneous assignment. there can be
-        * later use of an earlier lvalue.
-        */
+       Iter save1, save2;
+       Node *l1, *l2;
+       int c1, c2;
+
+       l1 = listfirst(&save1, &n);
+       c1 = 0;
+
+       while(l1 != N) {
+               l2 = listfirst(&save1, &n);
+               c2 = 0;
+               while(l2 != N) {
+                       if(c2 > c1) {
+                               if(vmatch(l1->left, l2->right)) {
+                               }
+                       }
+                       l2 = listnext(&save1);
+                       c2++;
+               }
+               l1 = listnext(&save1);
+               c1++;
+       }
        return n;
 }
 

diff --git a/src/runtime/rt0_amd64_darwin.s b/src/runtime/rt0_amd64_darwin.s
index 9aefd769bdcf8eeb3a3eb998d6124806b57c670e..e2794183bfcf4309349b867334254fa0302a0ccc 100644 (file)
--- a/src/runtime/rt0_amd64_darwin.s
+++ b/src/runtime/rt0_amd64_darwin.s
@@ -31,7 +31,7 @@ done:
        ADDQ    $16, SP
        CALL    check(SB)
        CALL    main_main(SB)
-       CALL    sys_exit(SB)
+       CALL    sys·exit(SB)
        CALL    notok(SB)
        POPQ    AX
        RET
@@ -39,7 +39,7 @@ done:
 TEXT   FLUSH(SB),1,$-8
        RET
 
-TEXT   sys_exit(SB),1,$-8
+TEXT   sys·exit(SB),1,$-8
        MOVL    8(SP), DI               // arg 1 exit status
        MOVL    $(0x2000000+1), AX
        SYSCALL
@@ -47,7 +47,7 @@ TEXT  sys_exit(SB),1,$-8
        CALL    notok(SB)
        RET
 
-TEXT   sys_write(SB),1,$-8
+TEXT   sys·write(SB),1,$-8
        MOVL    8(SP), DI               // arg 1 fid
        MOVQ    16(SP), SI              // arg 2 buf
        MOVL    24(SP), DX              // arg 3 count
@@ -57,7 +57,7 @@ TEXT  sys_write(SB),1,$-8
        CALL    notok(SB)
        RET
 
-TEXT   sys_sigaction(SB),1,$-8
+TEXT   sys·sigaction(SB),1,$-8
        MOVL    8(SP), DI               // arg 1 sig
        MOVQ    16(SP), SI              // arg 2 act
        MOVQ    24(SP), DX              // arg 3 oact
@@ -76,11 +76,11 @@ TEXT sigtramp(SB),1,$24
        CALL    sighandler(SB)
        RET
 
-TEXT   sys_breakpoint(SB),1,$-8
+TEXT   sys·breakpoint(SB),1,$-8
        BYTE    $0xcc
        RET
 
-TEXT   sys_mmap(SB),1,$-8
+TEXT   sys·mmap(SB),1,$-8
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), SI              // arg 2 len
        MOVL    20(SP), DX              // arg 3 prot
@@ -98,7 +98,7 @@ TEXT  notok(SB),1,$-8
        MOVQ    BP, (BP)
        RET
 
-TEXT   sys_memclr(SB),1,$-8
+TEXT   sys·memclr(SB),1,$-8
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), CX              // arg 2 count
        ADDL    $7, CX
@@ -109,7 +109,7 @@ TEXT        sys_memclr(SB),1,$-8
        STOSQ
        RET
 
-TEXT   sys_getcallerpc+0(SB),0,$0
+TEXT   sys·getcallerpc+0(SB),0,$0
        MOVQ    x+0(FP),AX
        MOVQ    -8(AX),AX
        RET

diff --git a/src/runtime/rt0_amd64_linux.s b/src/runtime/rt0_amd64_linux.s
index 27064a48bcd16c4c766a986632d2450a961ba668..30f72728ad4235d23e93b68b2c28c845a48edd38 100644 (file)
--- a/src/runtime/rt0_amd64_linux.s
+++ b/src/runtime/rt0_amd64_linux.s
@@ -25,8 +25,8 @@ loop:
 done:
        ADDQ    $8, CX
        CALL    check(SB)
-       CALL    main_main(SB)
-       CALL    sys_exit(SB)
+       CALL    main·main(SB)
+       CALL    sys·exit(SB)
        CALL    notok(SB)
        POPQ    AX
        RET
@@ -34,7 +34,7 @@ done:
 TEXT   FLUSH(SB),1,$-8
        RET
 
-TEXT   sys_exit(SB),1,$-8
+TEXT   sys·exit(SB),1,$-8
        MOVL    8(SP), DI
        MOVL    $60, AX
        SYSCALL
@@ -42,7 +42,7 @@ TEXT  sys_exit(SB),1,$-8
        CALL    notok(SB)
        RET
 
-TEXT   sys_write(SB),1,$-8
+TEXT   sys·write(SB),1,$-8
        MOVL    8(SP), DI
        MOVQ    16(SP), SI
        MOVL    24(SP), DX
@@ -52,7 +52,7 @@ TEXT  sys_write(SB),1,$-8
        CALL    notok(SB)
        RET
 
-TEXT   sys_rt_sigaction(SB),1,$-8
+TEXT   sys·rt_sigaction(SB),1,$-8
        MOVL    8(SP), DI
        MOVQ    16(SP), SI
        MOVQ    24(SP), DX
@@ -64,18 +64,18 @@ TEXT        sys_rt_sigaction(SB),1,$-8
        CALL    notok(SB)
        RET
 
-TEXT sigtramp(SB),1,$24
+TEXT   sigtramp(SB),1,$24
        MOVQ    DI,0(SP)
        MOVQ    SI,8(SP)
        MOVQ    DX,16(SP)
        CALL    sighandler(SB)
        RET
 
-TEXT   sys_breakpoint(SB),1,$-8
+TEXT   sys·breakpoint(SB),1,$-8
        BYTE    $0xcc
        RET
 
-TEXT   sys_mmap(SB),1,$-8
+TEXT   sys·mmap(SB),1,$-8
        MOVQ    8(SP), DI
        MOVL    16(SP), SI
        MOVL    20(SP), DX
@@ -103,7 +103,7 @@ TEXT        notok(SB),1,$-8
        MOVQ    BP, (BP)
        RET
 
-TEXT   sys_memclr(SB),1,$-8
+TEXT   sys·memclr(SB),1,$-8
        MOVQ    8(SP), DI               // arg 1 addr
        MOVL    16(SP), CX              // arg 2 count
        ADDL    $7, CX
@@ -114,7 +114,7 @@ TEXT        sys_memclr(SB),1,$-8
        STOSQ
        RET
 
-TEXT   sys_getcallerpc+0(SB),0,$0
+TEXT   sys·getcallerpc+0(SB),0,$0
        MOVQ    x+0(FP),AX
        MOVQ    -8(AX),AX
        RET

diff --git a/src/runtime/rt1_amd64_darwin.c b/src/runtime/rt1_amd64_darwin.c
index f9bc30570d2af798feb6e87e6c32fcca2b5aec84..4603b792cf97e6b1829298f2452ed7d8bbb03723 100644 (file)
--- a/src/runtime/rt1_amd64_darwin.c
+++ b/src/runtime/rt1_amd64_darwin.c
@@ -39,27 +39,27 @@ _STRUCT_X86_THREAD_STATE64
 void
 print_thread_state(_STRUCT_X86_THREAD_STATE64* ss)
 {
-       prints("\nrax     0x");  sys_printpointer((void*)ss->__rax);
-       prints("\nrbx     0x");  sys_printpointer((void*)ss->__rbx);
-       prints("\nrcx     0x");  sys_printpointer((void*)ss->__rcx);
-       prints("\nrdx     0x");  sys_printpointer((void*)ss->__rdx);
-       prints("\nrdi     0x");  sys_printpointer((void*)ss->__rdi);
-       prints("\nrsi     0x");  sys_printpointer((void*)ss->__rsi);
-       prints("\nrbp     0x");  sys_printpointer((void*)ss->__rbp);
-       prints("\nrsp     0x");  sys_printpointer((void*)ss->__rsp);
-       prints("\nr8      0x");  sys_printpointer((void*)ss->__r8 );
-       prints("\nr9      0x");  sys_printpointer((void*)ss->__r9 );
-       prints("\nr10     0x");  sys_printpointer((void*)ss->__r10);
-       prints("\nr11     0x");  sys_printpointer((void*)ss->__r11);
-       prints("\nr12     0x");  sys_printpointer((void*)ss->__r12);
-       prints("\nr13     0x");  sys_printpointer((void*)ss->__r13);
-       prints("\nr14     0x");  sys_printpointer((void*)ss->__r14);
-       prints("\nr15     0x");  sys_printpointer((void*)ss->__r15);
-       prints("\nrip     0x");  sys_printpointer((void*)ss->__rip);
-       prints("\nrflags  0x");  sys_printpointer((void*)ss->__rflags);
-       prints("\ncs      0x");  sys_printpointer((void*)ss->__cs);
-       prints("\nfs      0x");  sys_printpointer((void*)ss->__fs);
-       prints("\ngs      0x");  sys_printpointer((void*)ss->__gs);
+       prints("\nrax     0x");  sys·printpointer((void*)ss->__rax);
+       prints("\nrbx     0x");  sys·printpointer((void*)ss->__rbx);
+       prints("\nrcx     0x");  sys·printpointer((void*)ss->__rcx);
+       prints("\nrdx     0x");  sys·printpointer((void*)ss->__rdx);
+       prints("\nrdi     0x");  sys·printpointer((void*)ss->__rdi);
+       prints("\nrsi     0x");  sys·printpointer((void*)ss->__rsi);
+       prints("\nrbp     0x");  sys·printpointer((void*)ss->__rbp);
+       prints("\nrsp     0x");  sys·printpointer((void*)ss->__rsp);
+       prints("\nr8      0x");  sys·printpointer((void*)ss->__r8 );
+       prints("\nr9      0x");  sys·printpointer((void*)ss->__r9 );
+       prints("\nr10     0x");  sys·printpointer((void*)ss->__r10);
+       prints("\nr11     0x");  sys·printpointer((void*)ss->__r11);
+       prints("\nr12     0x");  sys·printpointer((void*)ss->__r12);
+       prints("\nr13     0x");  sys·printpointer((void*)ss->__r13);
+       prints("\nr14     0x");  sys·printpointer((void*)ss->__r14);
+       prints("\nr15     0x");  sys·printpointer((void*)ss->__r15);
+       prints("\nrip     0x");  sys·printpointer((void*)ss->__rip);
+       prints("\nrflags  0x");  sys·printpointer((void*)ss->__rflags);
+       prints("\ncs      0x");  sys·printpointer((void*)ss->__cs);
+       prints("\nfs      0x");  sys·printpointer((void*)ss->__fs);
+       prints("\ngs      0x");  sys·printpointer((void*)ss->__gs);
        prints("\n");
 }
 
@@ -134,7 +134,7 @@ sighandler(int32 sig, siginfo *info, void *context)
 {
        if(sig < 0 || sig >= NSIG){
                prints("Signal ");
-               sys_printint(sig);
+               sys·printint(sig);
        }else{
                prints(sigtab[sig].name);
        }
@@ -142,14 +142,14 @@ sighandler(int32 sig, siginfo *info, void *context)
         _STRUCT_MCONTEXT64 *uc_mcontext = get_uc_mcontext(context);
         _STRUCT_X86_THREAD_STATE64 *ss = get___ss(uc_mcontext);
 
-       prints("\nFaulting address: 0x");  sys_printpointer(info->si_addr);
-        prints("\npc: 0x");  sys_printpointer((void *)ss->__rip);
+       prints("\nFaulting address: 0x");  sys·printpointer(info->si_addr);
+        prints("\npc: 0x");  sys·printpointer((void *)ss->__rip);
         prints("\n\n");
         
        traceback((void *)ss->__rip, (void *)ss->__rsp);
         print_thread_state(ss);
         
-       sys_exit(2);
+       sys·exit(2);
 }
 
 sigaction a;
@@ -167,6 +167,6 @@ initsig(void)
 
        for(i = 0; i <NSIG; i++)
                if(sigtab[i].catch){
-                       sys_sigaction(i, &a, (void*)0);
+                       sys·sigaction(i, &a, (void*)0);
                }
 }

diff --git a/src/runtime/rt1_amd64_linux.c b/src/runtime/rt1_amd64_linux.c
index 6c8b051dd83626604931754a0089e4682b1349bd..6c187a44efffbc9947d4b79fcdd262f03dbaddbf 100644 (file)
--- a/src/runtime/rt1_amd64_linux.c
+++ b/src/runtime/rt1_amd64_linux.c
@@ -40,20 +40,20 @@ sighandler(int32 sig, siginfo* info, void** context) {
 
        if(sig < 0 || sig >= NSIG){
                prints("Signal ");
-               sys_printint(sig);
+               sys·printint(sig);
        }else{
                prints(sigtab[sig].name);
        }
        prints("\nFaulting address: 0x");
-       sys_printpointer(info->si_addr);
+       sys·printpointer(info->si_addr);
        prints("\nPC: 0x");
-       sys_printpointer(context[21]);
+       sys·printpointer(context[21]);
        prints("\nSP: 0x");
-       sys_printpointer(context[20]);
+       sys·printpointer(context[20]);
        prints("\n");
        traceback(context[21], context[20]);    /* empirically discovered locations */
-       sys_breakpoint();
-       sys_exit(2);
+       sys·breakpoint();
+       sys·exit(2);
 }
 
 sigaction a;
@@ -69,6 +69,6 @@ initsig(void)
 
        for(i = 0; i <NSIG; i++)
                if(sigtab[i].catch){
-                       sys_rt_sigaction(i, &a, (void*)0, 8);
+                       sys·rt_sigaction(i, &a, (void*)0, 8);
                }
 }

diff --git a/src/runtime/rt2_amd64.c b/src/runtime/rt2_amd64.c
index 1145ff72f821296aceda30e25654cbe099dda78c..f544ddd213944e153cca16ee9a688f781369b4aa 100644 (file)
--- a/src/runtime/rt2_amd64.c
+++ b/src/runtime/rt2_amd64.c
@@ -22,7 +22,7 @@ traceback(uint8 *pc, uint8 *sp)
        name = "panic";
        for(;;){
                prints("0x");
-               sys_printpointer(pc);
+               sys·printpointer(pc);
                prints("?zi\n");
                /* find SP offset by stepping back through instructions to SP offset marker */
                while(pc > (uint8*)0x1000+sizeof spmark-1) {
@@ -50,7 +50,7 @@ traceback(uint8 *pc, uint8 *sp)
                for(i = 0; i < 3; i++){
                        if(i != 0)
                                prints(", ");
-                       sys_printint(((uint32*)sp)[i]);
+                       sys·printint(((uint32*)sp)[i]);
                }
                prints(", ...)\n");
                prints("\t");
@@ -60,7 +60,7 @@ traceback(uint8 *pc, uint8 *sp)
                        if(i != 0)
                                prints(", ");
                        prints("0x");
-                       sys_printpointer(((void**)sp)[i]);
+                       sys·printpointer(((void**)sp)[i]);
                }
                prints(", ...)\n");
                /* print pc for next frame */

diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c
index 9c668633b44a57ebef275d4c7c275c44bc2023ec..c15316351829ea72626a5b70a264ddfce5675266 100644 (file)
--- a/src/runtime/runtime.c
+++ b/src/runtime/runtime.c
@@ -10,23 +10,23 @@ static      int32   empty           = 0;
 static string  emptystring     = (string)∅
 
 void
-sys_printbool(bool v)
+sys·printbool(bool v)
 {
        if(v) {
-               sys_write(1, (byte*)"true", 4);
+               sys·write(1, (byte*)"true", 4);
                return;
        }
-       sys_write(1, (byte*)"false", 5);
+       sys·write(1, (byte*)"false", 5);
 }
 
 void
-sys_printfloat(float64 v)
+sys·printfloat(float64 v)
 {
-       sys_write(1, "printfloat", 10);
+       sys·write(1, "printfloat", 10);
 }
 
 void
-sys_printint(int64 v)
+sys·printint(int64 v)
 {
        byte buf[100];
        int32 i, s;
@@ -36,7 +36,7 @@ sys_printint(int64 v)
                v = -v;
                s = 1;
                if(v < 0) {
-                       sys_write(1, (byte*)"-oo", 3);
+                       sys·write(1, (byte*)"-oo", 3);
                        return;
                }
        }
@@ -51,11 +51,11 @@ sys_printint(int64 v)
                i--;
                buf[i] = '-';
        }
-       sys_write(1, buf+i, nelem(buf)-i);
+       sys·write(1, buf+i, nelem(buf)-i);
 }
 
 void
-sys_printpointer(void *p)
+sys·printpointer(void *p)
 {
        uint64 v;
        byte buf[100];
@@ -70,14 +70,14 @@ sys_printpointer(void *p)
                        break;
                v = v/16;
        }
-       sys_write(1, buf+i, nelem(buf)-i);
+       sys·write(1, buf+i, nelem(buf)-i);
 }
 
 void
-sys_printstring(string v)
+sys·printstring(string v)
 {
        if(v != nil)
-               sys_write(1, v->str, v->len);
+               sys·write(1, v->str, v->len);
 }
 
 int32
@@ -93,31 +93,31 @@ findnull(int8 *s)
 void
 prints(int8 *s)
 {
-       sys_write(1, s, findnull(s));
+       sys·write(1, s, findnull(s));
 }
 
 void
-sys_printpc(void *p)
+sys·printpc(void *p)
 {
        prints("PC=0x");
-       sys_printpointer(sys_getcallerpc(p));
+       sys·printpointer(sys·getcallerpc(p));
 }
 
 /*BUG: move traceback code to architecture-dependent runtime */
 void
-sys_panicl(int32 lno)
+sys·panicl(int32 lno)
 {
        uint8 *sp;
 
        prints("\npanic on line ");
-       sys_printint(lno);
+       sys·printint(lno);
        prints(" ");
-       sys_printpc(&lno);
+       sys·printpc(&lno);
        prints("\n");
        sp = (uint8*)&lno;
-       traceback(sys_getcallerpc(&lno), sp);
-       sys_breakpoint();
-       sys_exit(2);
+       traceback(sys·getcallerpc(&lno), sp);
+       sys·breakpoint();
+       sys·exit(2);
 }
 
 dump(byte *p, int32 n)
@@ -126,8 +126,8 @@ dump(byte *p, int32 n)
        int32 i;
 
        for(i=0; i<n; i++) {
-               sys_printpointer((byte*)(p[i]>>4));
-               sys_printpointer((byte*)(p[i]&0xf));
+               sys·printpointer((byte*)(p[i]>>4));
+               sys·printpointer((byte*)(p[i]&0xf));
                if((i&15) == 15)
                        prints("\n");
                else
@@ -163,7 +163,8 @@ throw(int8 *s)
        prints("throw: ");
        prints(s);
        prints("\n");
-       sys_exit(1);
+       *(int32*)0 = 0;
+       sys·exit(1);
 }
 
 void
@@ -182,8 +183,8 @@ brk(uint32 n)
 {
        byte* v;
 
-       v = sys_mmap(nil, NHUNK, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
-       sys_memclr(v, n);
+       v = sys·mmap(nil, NHUNK, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
+       sys·memclr(v, n);
        nmmap += n;
        return v;
 }
@@ -248,14 +249,14 @@ cmpstring(string s1, string s2)
 }
 
 void
-sys_mal(uint32 n, uint8 *ret)
+sys·mal(uint32 n, uint8 *ret)
 {
        ret = mal(n);
        FLUSH(&ret);
 }
 
 void
-sys_catstring(string s1, string s2, string s3)
+sys·catstring(string s1, string s2, string s3)
 {
        uint32 l;
 
@@ -280,7 +281,7 @@ out:
 }
 
 void
-sys_cmpstring(string s1, string s2, int32 v)
+sys·cmpstring(string s1, string s2, int32 v)
 {
        v = cmpstring(s1, s2);
        FLUSH(&v);
@@ -311,17 +312,17 @@ prbounds(int8* s, int32 a, int32 b, int32 c)
 
        prints(s);
        prints(" ");
-       sys_printint(a);
+       sys·printint(a);
        prints("<");
-       sys_printint(b);
+       sys·printint(b);
        prints(">");
-       sys_printint(c);
+       sys·printint(c);
        prints("\n");
        throw("bounds");
 }
 
 void
-sys_slicestring(string si, int32 lindex, int32 hindex, string so)
+sys·slicestring(string si, int32 lindex, int32 hindex, string so)
 {
        string s, str;
        int32 l;
@@ -331,7 +332,7 @@ sys_slicestring(string si, int32 lindex, int32 hindex, string so)
 
        if(lindex < 0 || lindex > si->len ||
           hindex < lindex || hindex > si->len) {
-               sys_printpc(&si);
+               sys·printpc(&si);
                prints(" ");
                prbounds("slice", lindex, si->len, hindex);
        }
@@ -344,13 +345,13 @@ sys_slicestring(string si, int32 lindex, int32 hindex, string so)
 }
 
 void
-sys_indexstring(string s, int32 i, byte b)
+sys·indexstring(string s, int32 i, byte b)
 {
        if(s == nil)
                s = emptystring;
 
        if(i < 0 || i >= s->len) {
-               sys_printpc(&s);
+               sys·printpc(&s);
                prints(" ");
                prbounds("index", 0, i, s->len);
        }
@@ -409,7 +410,7 @@ runetochar(byte *str, uint32 c)
 }
 
 void
-sys_intstring(int64 v, string s)
+sys·intstring(int64 v, string s)
 {
        int32 l;
 
@@ -419,7 +420,7 @@ sys_intstring(int64 v, string s)
 }
 
 void
-sys_byteastring(byte *a, int32 l, string s)
+sys·byteastring(byte *a, int32 l, string s)
 {
        s = mal(sizeof(s->len)+l);
        s->len = l;
@@ -494,16 +495,16 @@ loop2:
 }
 
 void
-sys_ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
+sys·ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
 {
 
        if(debug) {
                prints("s2i sigi=");
-               sys_printpointer(si);
+               sys·printpointer(si);
                prints(" sigs=");
-               sys_printpointer(ss);
+               sys·printpointer(ss);
                prints(" s=");
-               sys_printpointer(s);
+               sys·printpointer(s);
        }
 
        if(s == nil) {
@@ -517,9 +518,9 @@ sys_ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
 
        if(debug) {
                prints(" returning m=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints(" s=");
-               sys_printpointer(s);
+               sys·printpointer(s);
                prints("\n");
                dump((byte*)m, 64);
        }
@@ -528,16 +529,16 @@ sys_ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
 }
 
 void
-sys_ifacei2i(Sigi *si, Map *m, void *s)
+sys·ifacei2i(Sigi *si, Map *m, void *s)
 {
 
        if(debug) {
                prints("i2i sigi=");
-               sys_printpointer(si);
+               sys·printpointer(si);
                prints(" m=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints(" s=");
-               sys_printpointer(s);
+               sys·printpointer(s);
        }
 
        if(m == nil) {
@@ -559,23 +560,23 @@ sys_ifacei2i(Sigi *si, Map *m, void *s)
 
        if(debug) {
                prints(" returning m=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints(" s=");
-               sys_printpointer(s);
+               sys·printpointer(s);
                prints("\n");
                dump((byte*)m, 64);
        }
 }
 
 void
-sys_ifacei2s(Sigs *ss, Map *m, void *s)
+sys·ifacei2s(Sigs *ss, Map *m, void *s)
 {
 
        if(debug) {
                prints("i2s m=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints(" s=");
-               sys_printpointer(s);
+               sys·printpointer(s);
                prints("\n");
        }
 
@@ -727,7 +728,7 @@ modf(float64 d, float64 *ip)
 
 // func frexp(float64) (int32, float64); // break fp into exp,fract
 void
-sys_frexp(float64 din, int32 iou, float64 dou)
+sys·frexp(float64 din, int32 iou, float64 dou)
 {
        dou = frexp(din, &iou);
        FLUSH(&dou);
@@ -735,7 +736,7 @@ sys_frexp(float64 din, int32 iou, float64 dou)
 
 //func ldexp(int32, float64) float64;  // make fp from exp,fract
 void
-sys_ldexp(float64 din, int32 ein, float64 dou)
+sys·ldexp(float64 din, int32 ein, float64 dou)
 {
        dou = ldexp(din, ein);
        FLUSH(&dou);
@@ -743,7 +744,7 @@ sys_ldexp(float64 din, int32 ein, float64 dou)
 
 //func modf(float64) (float64, float64);       // break fp into double+double
 float64
-sys_modf(float64 din, float64 dou1, float64 dou2)
+sys·modf(float64 din, float64 dou1, float64 dou2)
 {
        dou1 = modf(din, &dou2);
        FLUSH(&dou2);
@@ -854,7 +855,7 @@ memprint(uint32 s, void *a)
                v = *(uint64*)a;
                break;
        }
-       sys_printint(v);
+       sys·printint(v);
 }
 
 static void
@@ -890,7 +891,7 @@ stringequal(uint32 s, string *a, string *b)
 static void
 stringprint(uint32 s, string *a)
 {
-       sys_printstring(*a);
+       sys·printstring(*a);
 }
 
 static void
@@ -925,7 +926,7 @@ algarray[] =
 //     keyalg uint32, valalg uint32,
 //     hint uint32) (hmap *map[any]any);
 void
-sys_newmap(uint32 keysize, uint32 valsize,
+sys·newmap(uint32 keysize, uint32 valsize,
        uint32 keyalg, uint32 valalg, uint32 hint,
        Hmap* ret)
 {
@@ -934,16 +935,16 @@ sys_newmap(uint32 keysize, uint32 valsize,
        if(keyalg >= nelem(algarray) ||
           valalg >= nelem(algarray)) {
                prints("0<=");
-               sys_printint(keyalg);
+               sys·printint(keyalg);
                prints("<");
-               sys_printint(nelem(algarray));
+               sys·printint(nelem(algarray));
                prints("\n0<=");
-               sys_printint(valalg);
+               sys·printint(valalg);
                prints("<");
-               sys_printint(nelem(algarray));
+               sys·printint(nelem(algarray));
                prints("\n");
 
-               throw("sys_newmap: key/val algorithm out of range");
+               throw("sys·newmap: key/val algorithm out of range");
        }
 
        m = mal(sizeof(*m));
@@ -966,30 +967,30 @@ sys_newmap(uint32 keysize, uint32 valsize,
 
        if(debug) {
                prints("newmap: map=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints("; keysize=");
-               sys_printint(keysize);
+               sys·printint(keysize);
                prints("; valsize=");
-               sys_printint(valsize);
+               sys·printint(valsize);
                prints("; keyalg=");
-               sys_printint(keyalg);
+               sys·printint(keyalg);
                prints("; valalg=");
-               sys_printint(valalg);
+               sys·printint(valalg);
                prints("; valoffset=");
-               sys_printint(m->valoffset);
+               sys·printint(m->valoffset);
                prints("; ko=");
-               sys_printint(m->ko);
+               sys·printint(m->ko);
                prints("; vo=");
-               sys_printint(m->vo);
+               sys·printint(m->vo);
                prints("; po=");
-               sys_printint(m->po);
+               sys·printint(m->po);
                prints("\n");
        }
 }
 
 // mapaccess1(hmap *map[any]any, key any) (val any);
 void
-sys_mapaccess1(Hmap *m, ...)
+sys·mapaccess1(Hmap *m, ...)
 {
        Link *l;
        byte *ak, *av;
@@ -1008,8 +1009,8 @@ sys_mapaccess1(Hmap *m, ...)
 
 out:
        if(debug) {
-               prints("sys_mapaccess1: map=");
-               sys_printpointer(m);
+               prints("sys·mapaccess1: map=");
+               sys·printpointer(m);
                prints("; key=");
                m->keyalg->print(m->keysize, ak);
                prints("; val=");
@@ -1020,7 +1021,7 @@ out:
 
 // mapaccess2(hmap *map[any]any, key any) (val any, pres bool);
 void
-sys_mapaccess2(Hmap *m, ...)
+sys·mapaccess2(Hmap *m, ...)
 {
        Link *l;
        byte *ak, *av, *ap;
@@ -1042,20 +1043,20 @@ sys_mapaccess2(Hmap *m, ...)
 
 out:
        if(debug) {
-               prints("sys_mapaccess2: map=");
-               sys_printpointer(m);
+               prints("sys·mapaccess2: map=");
+               sys·printpointer(m);
                prints("; key=");
                m->keyalg->print(m->keysize, ak);
                prints("; val=");
                m->valalg->print(m->valsize, av);
                prints("; pres=");
-               sys_printbool(*ap);
+               sys·printbool(*ap);
                prints("\n");
        }
 }
 
 static void
-sys_mapassign(Hmap *m, byte *ak, byte *av)
+sys·mapassign(Hmap *m, byte *ak, byte *av)
 {
        Link *l;
 
@@ -1077,7 +1078,7 @@ out:
 
        if(debug) {
                prints("mapassign: map=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints("; key=");
                m->keyalg->print(m->keysize, ak);
                prints("; val=");
@@ -1088,7 +1089,7 @@ out:
 
 // mapassign1(hmap *map[any]any, key any, val any);
 void
-sys_mapassign1(Hmap *m, ...)
+sys·mapassign1(Hmap *m, ...)
 {
        Link **ll;
        byte *ak, *av;
@@ -1096,12 +1097,12 @@ sys_mapassign1(Hmap *m, ...)
        ak = (byte*)&m + m->ko;
        av = (byte*)&m + m->vo;
 
-       sys_mapassign(m, ak, av);
+       sys·mapassign(m, ak, av);
 }
 
 // mapassign2(hmap *map[any]any, key any, val any, pres bool);
 void
-sys_mapassign2(Hmap *m, ...)
+sys·mapassign2(Hmap *m, ...)
 {
        Link **ll;
        byte *ak, *av, *ap;
@@ -1112,7 +1113,7 @@ sys_mapassign2(Hmap *m, ...)
 
        if(*ap == true) {
                // assign
-               sys_mapassign(m, ak, av);
+               sys·mapassign(m, ak, av);
                return;
        }
 
@@ -1124,7 +1125,7 @@ sys_mapassign2(Hmap *m, ...)
                        m->len--;
                        if(debug) {
                                prints("mapdelete (found): map=");
-                               sys_printpointer(m);
+                               sys·printpointer(m);
                                prints("; key=");
                                m->keyalg->print(m->keysize, ak);
                                prints("\n");
@@ -1135,7 +1136,7 @@ sys_mapassign2(Hmap *m, ...)
 
        if(debug) {
                prints("mapdelete (not found): map=");
-               sys_printpointer(m);
+               sys·printpointer(m);
                prints("; key=");
                m->keyalg->print(m->keysize, ak);
                prints(" *** not found\n");

diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index 15b33a070e9149e6b245221dafc57fddcd240e5e..4d185a5dc7349610562cd26c99a6be99076363de 100644 (file)
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -90,7 +90,8 @@ void* mal(uint32);
 uint32 cmpstring(string, string);
 void   initsig(void);
 void   traceback(uint8 *pc, uint8 *sp);
-struct SigTab {
+struct SigTab
+{
        int32   catch;
        int8    *name;
 };
@@ -98,28 +99,28 @@ struct SigTab {
 /*
  * low level go -called
  */
-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);
-void*  sys_getcallerpc(void*);
-void   sys_sigaction(int64, void*, void*);
-void   sys_rt_sigaction(int64, void*, void*, uint64);
+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);
+void*  sys·getcallerpc(void*);
+void   sys·sigaction(int64, void*, void*);
+void   sys·rt_sigaction(int64, void*, void*, uint64);
 
 /*
  * runtime go-called
  */
-void   sys_printbool(bool);
-void   sys_printfloat(float64);
-void   sys_printint(int64);
-void   sys_printstring(string);
-void   sys_printpointer(void*);
-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*);
+void   sys·printbool(bool);
+void   sys·printfloat(float64);
+void   sys·printint(int64);
+void   sys·printstring(string);
+void   sys·printpointer(void*);
+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*);