⚡ add u32 and() xor() or() nand() not()

lib.nas

@@ -338,16 +338,27 @@ var fstat=func(filename){
 # carefully use it, all the calculations are based on integer.
 var bits=
 {
-    # xor
+    # i32 xor
-    bitxor:  func(a,b){return __builtin_xor(a,b); },
+    i32_xor: func(a,b){return __builtin_i32xor(a,b); },
-    # and
+    # i32 and
-    bitand:  func(a,b){return __builtin_and(a,b); },
+    i32_and: func(a,b){return __builtin_i32and(a,b); },
-    # or
+    # i32 or
-    bitor:   func(a,b){return __builtin_or(a,b);  },
+    i32_or:  func(a,b){return __builtin_i32or(a,b);  },
-    # nand
+    # i32 nand
-    bitnand: func(a,b){return __builtin_nand(a,b);},
+    i32_nand:func(a,b){return __builtin_i32nand(a,b);},
-    # not
+    # i32 not
-    bitnot:  func(a)  {return __builtin_not(a);   },
+    i32_not: func(a)  {return __builtin_i32not(a);   },
+    # u32 xor
+    u32_xor: func(a,b){return __builtin_u32xor(a,b); },
+    # u32 and
+    u32_and: func(a,b){return __builtin_u32and(a,b); },
+    # u32 or
+    u32_or:  func(a,b){return __builtin_u32or(a,b);  },
+    # u32 nand
+    u32_nand:func(a,b){return __builtin_u32nand(a,b);},
+    # u32 not
+    u32_not: func(a)  {return __builtin_u32not(a);   },
+
     # get bit data from a special string. for example:
     # bits.fld(s,0,3);
     # if s stores 10100010(162)
@@ -399,8 +410,8 @@ var unix=
     dup2:     func(fd0,fd1){die("not supported yet");},
     exec:     func(filename,argv,envp){die("not supported yet");},
     waitpid:  func(pid,nohang=0){return __builtin_waitpid;},
-    isdir:    func(path){return bits.bitand(io.stat(path)[2],0x4000);}, # S_IFDIR 0x4000
+    isdir:    func(path){return bits.u32_and(io.stat(path)[2],0x4000);}, # S_IFDIR 0x4000
-    isfile:   func(path){return bits.bitand(io.stat(path)[2],0x8000);}, # S_IFREG 0x8000
+    isfile:   func(path){return bits.u32_and(io.stat(path)[2],0x8000);}, # S_IFREG 0x8000
     opendir:  func(path){return __builtin_opendir;},
     readdir:  func(handle){return __builtin_readdir;},
     closedir: func(handle){return __builtin_closedir;},

nasal_builtin.h

@@ -26,11 +26,16 @@ nas_native(builtin_num);
 nas_native(builtin_pop);
 nas_native(builtin_str);
 nas_native(builtin_size);
-nas_native(builtin_xor);
+nas_native(builtin_i32xor);
-nas_native(builtin_and);
+nas_native(builtin_i32and);
-nas_native(builtin_or);
+nas_native(builtin_i32or);
-nas_native(builtin_nand);
+nas_native(builtin_i32nand);
-nas_native(builtin_not);
+nas_native(builtin_i32not);
+nas_native(builtin_u32xor);
+nas_native(builtin_u32and);
+nas_native(builtin_u32or);
+nas_native(builtin_u32nand);
+nas_native(builtin_u32not);
 nas_native(builtin_pow);
 nas_native(builtin_sin);
 nas_native(builtin_cos);
@@ -125,11 +130,16 @@ struct
     {"__builtin_pop",     builtin_pop     },
     {"__builtin_str",     builtin_str     },
     {"__builtin_size",    builtin_size    },
-    {"__builtin_xor",     builtin_xor     },
+    {"__builtin_i32xor",  builtin_i32xor  },
-    {"__builtin_and",     builtin_and     },
+    {"__builtin_i32and",  builtin_i32and  },
-    {"__builtin_or",      builtin_or      },
+    {"__builtin_i32or",   builtin_i32or   },
-    {"__builtin_nand",    builtin_nand    },
+    {"__builtin_i32nand", builtin_i32nand },
-    {"__builtin_not",     builtin_not     },
+    {"__builtin_i32not",  builtin_i32not  },
+    {"__builtin_u32xor",  builtin_u32xor  },
+    {"__builtin_u32and",  builtin_u32and  },
+    {"__builtin_u32or",   builtin_u32or   },
+    {"__builtin_u32nand", builtin_u32nand },
+    {"__builtin_u32not",  builtin_u32not  },
     {"__builtin_pow",     builtin_pow     },
     {"__builtin_sin",     builtin_sin     },
     {"__builtin_cos",     builtin_cos     },
@@ -447,61 +457,63 @@ nasal_ref builtin_size(nasal_ref* local,nasal_gc& gc)
     }
     return {vm_num,num};
 }
-nasal_ref builtin_xor(nasal_ref* local,nasal_gc& gc)
+nasal_ref builtin_i32xor(nasal_ref* local,nasal_gc& gc)
 {
-    nasal_ref a=local[1];
+    int a=(int)local[1].num();
-    nasal_ref b=local[2];
+    int b=(int)local[2].num();
-    if(a.type!=vm_num)
+    return {vm_num,(double)(a^b)};
-        return builtin_err("xor","\"a\" must be number");
-    if(b.type!=vm_num)
-        return builtin_err("xor","\"b\" must be number");
-    int number_a=(int)a.num();
-    int number_b=(int)b.num();
-    return {vm_num,(double)(number_a^number_b)};
 }
-nasal_ref builtin_and(nasal_ref* local,nasal_gc& gc)
+nasal_ref builtin_i32and(nasal_ref* local,nasal_gc& gc)
 {
-    nasal_ref a=local[1];
+    int a=(int)local[1].num();
-    nasal_ref b=local[2];
+    int b=(int)local[2].num();
-    if(a.type!=vm_num)
+    return {vm_num,(double)(a&b)};
-        return builtin_err("and","\"a\" must be number");
-    if(b.type!=vm_num)
-        return builtin_err("and","\"b\" must be number");
-    int number_a=(int)a.num();
-    int number_b=(int)b.num();
-    return {vm_num,(double)(number_a&number_b)};
 }
-nasal_ref builtin_or(nasal_ref* local,nasal_gc& gc)
+nasal_ref builtin_i32or(nasal_ref* local,nasal_gc& gc)
 {
-    nasal_ref a=local[1];
+    int a=(int)local[1].num();
-    nasal_ref b=local[2];
+    int b=(int)local[2].num();
-    if(a.type!=vm_num)
+    return {vm_num,(double)(a|b)};
-        return builtin_err("or","\"a\" must be number");
-    if(b.type!=vm_num)
-        return builtin_err("or","\"b\" must be number");
-    int number_a=(int)a.num();
-    int number_b=(int)b.num();
-    return {vm_num,(double)(number_a|number_b)};
 }
-nasal_ref builtin_nand(nasal_ref* local,nasal_gc& gc)
+nasal_ref builtin_i32nand(nasal_ref* local,nasal_gc& gc)
 {
-    nasal_ref a=local[1];
+    int a=(int)local[1].num();
-    nasal_ref b=local[2];
+    int b=(int)local[2].num();
-    if(a.type!=vm_num)
+    return {vm_num,(double)(~(a&b))};
-        return builtin_err("nand","\"a\" must be number");
-    if(b.type!=vm_num)
-        return builtin_err("nand","\"b\" must be number");
-    int number_a=(int)a.num();
-    int number_b=(int)b.num();
-    return {vm_num,(double)(~(number_a&number_b))};
 }
-nasal_ref builtin_not(nasal_ref* local,nasal_gc& gc)
+nasal_ref builtin_i32not(nasal_ref* local,nasal_gc& gc)
 {
-    nasal_ref a=local[1];
+    int n=(int)local[1].num();
-    if(a.type!=vm_num)
+    return {vm_num,(double)(~n)};
-        return builtin_err("not","\"a\" must be number");
+}
-    int number=(int)a.num();
+nasal_ref builtin_u32xor(nasal_ref* local,nasal_gc& gc)
-    return {vm_num,(double)(~number)};
+{
+    uint32_t a=(uint32_t)local[1].num();
+    uint32_t b=(uint32_t)local[2].num();
+    return {vm_num,(double)(a^b)};
+}
+nasal_ref builtin_u32and(nasal_ref* local,nasal_gc& gc)
+{
+    uint32_t a=(uint32_t)local[1].num();
+    uint32_t b=(uint32_t)local[2].num();
+    return {vm_num,(double)(a&b)};
+}
+nasal_ref builtin_u32or(nasal_ref* local,nasal_gc& gc)
+{
+    uint32_t a=(uint32_t)local[1].num();
+    uint32_t b=(uint32_t)local[2].num();
+    return {vm_num,(double)(a|b)};
+}
+nasal_ref builtin_u32nand(nasal_ref* local,nasal_gc& gc)
+{
+    uint32_t a=(uint32_t)local[1].num();
+    uint32_t b=(uint32_t)local[2].num();
+    return {vm_num,(double)(~(a&b))};
+}
+nasal_ref builtin_u32not(nasal_ref* local,nasal_gc& gc)
+{
+    uint32_t n=(uint32_t)local[1].num();
+    return {vm_num,(double)(~n)};
 }
 nasal_ref builtin_pow(nasal_ref* local,nasal_gc& gc)
 {

stl/lib.nas

@@ -339,15 +339,26 @@ var fstat=func(filename){
 var bits=
 {
     # xor
-    bitxor:  func(a,b){return __builtin_xor(a,b); },
+    bitxor:  func(a,b){return __builtin_i32xor(a,b); },
     # and
-    bitand:  func(a,b){return __builtin_and(a,b); },
+    bitand:  func(a,b){return __builtin_i32and(a,b); },
     # or
-    bitor:   func(a,b){return __builtin_or(a,b);  },
+    bitor:   func(a,b){return __builtin_i32or(a,b);  },
     # nand
-    bitnand: func(a,b){return __builtin_nand(a,b);},
+    bitnand: func(a,b){return __builtin_i32nand(a,b);},
     # not
-    bitnot:  func(a)  {return __builtin_not(a);   },
+    bitnot:  func(a)  {return __builtin_i32not(a);   },
+    # u32 xor
+    u32_xor: func(a,b){return __builtin_u32xor(a,b); },
+    # u32 and
+    u32_and: func(a,b){return __builtin_u32and(a,b); },
+    # u32 or
+    u32_or:  func(a,b){return __builtin_u32or(a,b);  },
+    # u32 nand
+    u32_nand:func(a,b){return __builtin_u32nand(a,b);},
+    # u32 not
+    u32_not: func(a)  {return __builtin_u32not(a);   },
+
     # get bit data from a special string. for example:
     # bits.fld(s,0,3);
     # if s stores 10100010(162)
@@ -399,8 +410,8 @@ var unix=
     dup2:     func(fd0,fd1){die("not supported yet");},
     exec:     func(filename,argv,envp){die("not supported yet");},
     waitpid:  func(pid,nohang=0){return __builtin_waitpid;},
-    isdir:    func(path){return bits.bitand(io.stat(path)[2],0x4000);}, # S_IFDIR 0x4000
+    isdir:    func(path){return bits.u32_and(io.stat(path)[2],0x4000);}, # S_IFDIR 0x4000
-    isfile:   func(path){return bits.bitand(io.stat(path)[2],0x8000);}, # S_IFREG 0x8000
+    isfile:   func(path){return bits.u32_and(io.stat(path)[2],0x8000);}, # S_IFREG 0x8000
     opendir:  func(path){return __builtin_opendir;},
     readdir:  func(handle){return __builtin_readdir;},
     closedir: func(handle){return __builtin_closedir;},

test/md5.nas

@@ -4,47 +4,16 @@ var check=func(x){
     return x-floor(x/0x100000000)*0x100000000;
 }
 var u32_bits_and=func(x,y){
-    (x,y)=(check(x),check(y));
+    return bits.u32_and(check(x),check(y));
-    var (res,op)=(0,1);
-    for(var i=0;i<32;i+=1){
-        var (tmpx,tmpy)=(x-floor(x/2)*2,y-floor(y/2)*2);
-        res+=op*(tmpx==1 and tmpy==1);
-        (x,y)=(floor(x/2),floor(y/2));
-        op*=2;
-    }
-    return res;
 }
 var u32_bits_or=func(x,y){
-    (x,y)=(check(x),check(y));
+    return bits.u32_or(check(x),check(y));
-    var (res,op)=(0,1);
-    for(var i=0;i<32;i+=1){
-        var (tmpx,tmpy)=(x-floor(x/2)*2,y-floor(y/2)*2);
-        res+=op*(tmpx==1 or tmpy==1);
-        (x,y)=(floor(x/2),floor(y/2));
-        op*=2;
-    }
-    return res;
 }
 var u32_bits_xor=func(x,y){
-    (x,y)=(check(x),check(y));
+    return bits.u32_xor(check(x),check(y));
-    var (res,op)=(0,1);
-    for(var i=0;i<32;i+=1){
-        var (tmpx,tmpy)=(x-floor(x/2)*2,y-floor(y/2)*2);
-        res+=op*(tmpx!=tmpy);
-        (x,y)=(floor(x/2),floor(y/2));
-        op*=2;
-    }
-    return res;
 }
 var u32_bits_not=func(x){
-    x=check(x);
+    return bits.u32_not(check(x));
-    var (res,op)=(0,1);
-    for(var i=0;i<32;i+=1){
-        res+=op*((x-floor(x/2)*2)==1?0:1);
-        x=floor(x/2);
-        op*=2;
-    }
-    return res;
 }
 
 var hex32str=func(){

test/qrcode.nas

@@ -38,7 +38,7 @@ var transfer=func(s){
     var len=size(s);
     var vec=[0,0,0,0,0,0,0,0,0];
     for(var i=8;i>=0;i-=1){
-        vec[i]=bits.bitand(1,len);
+        vec[i]=bits.u32_and(1,len);
         len=int(len/2);
     }
     println(vec);
@@ -48,7 +48,7 @@ var transfer=func(s){
         var tmp=[0,0,0,0,0,0,0,0];
         var c=s[i];
         for(var j=7;j>=0;j-=1){
-            tmp[j]=bits.bitand(1,c);
+            tmp[j]=bits.u32_and(1,c);
             c=int(c/2);
         }
         foreach(var j;tmp)