add stl & more efficient scope

stl/lib.nas

@@ -0,0 +1,159 @@
+var import=func(filename)
+{
+    __builtin_import(filename);
+    return nil;
+}
+var print=func(elements...)
+{
+    __builtin_std_cout(elements);
+    return nil;
+};
+var println=func(elements...)
+{
+    __builtin_std_cout(elements);
+    print('\n');
+    return nil;
+}
+var append=func(vector,elements...)
+{
+    __builtin_push_back(vector,elements);
+    return nil;
+}
+var setsize=func(vector,size)
+{
+    __builtin_set_size(vector,size);
+    return nil;
+}
+var system=func(str)
+{
+    __builtin_system(str);
+    return;
+}
+var input=func()
+{
+    return __builtin_input();
+}
+var sleep=func(duration)
+{
+    __builtin_sleep(duration);
+    return;
+}
+var split=func(delimeter,string)
+{
+    return __builtin_split(delimeter,string);
+}
+var rand=func(seed=nil)
+{
+    return __builtin_rand(seed);
+}
+var id=func(thing)
+{
+    return __builtin_get_id(thing);
+}
+var int=func(value)
+{
+    return __builtin_int(value);
+}
+var num=func(value)
+{
+    return __builtin_num(value);
+}
+var pop=func(vector)
+{
+    return __builtin_pop_back(vector);
+}
+var str=func(number)
+{
+    return __builtin_str(number);
+}
+var size=func(object)
+{
+    return __builtin_size(object);
+}
+var contains=func(hash,key)
+{
+    return __builtin_contains(hash,key);
+}
+var delete=func(hash,key)
+{
+    __builtin_delete(hash,key);
+    return;
+}
+var keys=func(hash)
+{
+    return __builtin_get_keys(hash);
+}
+var time=func(begin_time)
+{
+    return __builtin_time(begin_time);
+}
+var die=func(str)
+{
+    __builtin_die(str);
+    return nil;
+}
+var typeof=func(object)
+{
+    return __builtin_type(object);
+}
+var substr=func(str,begin,length)
+{
+    return __builtin_substr(str,begin,length);
+}
+var streq=func(a,b)
+{
+    return __builtin_streq(a,b);
+}
+var left=func(string,length)
+{
+    return __builtin_left(string,length);
+}
+var right=func(string,length)
+{
+    return __builtin_right(string,length);
+}
+var cmp=func(a,b)
+{
+    return __builtin_cmp(a,b);
+}
+var chr=func(code) #//Unlike in FG, this chr does not support Extended ASCII
+{
+    return __builtin_chr(code);
+}
+
+var io=
+{
+    fin:func(filename)
+    {
+        return __builtin_fin(filename);
+    },
+    fout:func(filename,str)
+    {
+        __builtin_fout(filename,str);
+        return;
+    }
+};
+
+var bits=
+{
+    bitxor:  func(a,b){return __builtin_xor(a,b); },
+    bitand:  func(a,b){return __builtin_and(a,b); },
+    bitor:   func(a,b){return __builtin_or(a,b);  },
+    bitnand: func(a,b){return __builtin_nand(a,b);},
+    bitnot:  func(a)  {return __builtin_not(a);   }
+};
+
+var math=
+{
+    e:     2.7182818284590452354,
+    pi:    3.14159265358979323846264338327950288,
+    sin:   func(x)  {return __builtin_sin(x);    },
+    cos:   func(x)  {return __builtin_cos(x);    },
+    tan:   func(x)  {return __builtin_tan(x);    },
+    exp:   func(x)  {return __builtin_exp(x);    }, 
+    ln:    func(x)  {return __builtin_ln(x);     },
+    sqrt:  func(x)  {return __builtin_sqrt(x);   },
+    atan2: func(x,y){return __builtin_atan2(x,y);}
+};
+
+var D2R=math.pi/180;

stl/list.nas

@@ -0,0 +1,73 @@
+# lib list.nas
+# valkmjolnir 2021/3/31
+var list=func()
+{
+    var _={begin:nil,end:nil};
+    return
+    {
+        push_back:func(elem)
+        {
+            var tmp={elem:elem,prev:nil,next:nil};
+            if(_.end!=nil)
+            {
+                _.end.next=tmp;
+                tmp.prev=_.end;
+                _.end=tmp;
+            }
+            else
+            {
+                _.begin=tmp;
+                _.end=tmp;
+            }
+            return;
+        },
+        push_front:func(elem)
+        {
+            var tmp={elem:elem,prev:nil,next:nil};
+            if(_.begin!=nil)
+            {
+                _.begin.prev=tmp;
+                tmp.next=_.begin;
+                _.begin=tmp;
+            }
+            else
+            {
+                _.begin=tmp;
+                _.end=tmp;
+            }
+            return;
+        },
+        pop_back:func()
+        {
+            if(_.end!=nil)
+                _.end=_.end.prev;
+            if(_.end==nil)
+                _.begin=nil;
+            else
+                _.end.next=nil;
+            return;
+        },
+        pop_front:func()
+        {
+            if(_.begin!=nil)
+                _.begin=_.begin.next;
+            if(_.begin==nil)
+                _.end=nil;
+            else
+                _.begin.prev=nil;
+            return;
+        },
+        front:func()
+        {
+            if(_.begin!=nil)
+                return _.begin.elem;
+            return nil;
+        },
+        back:func()
+        {
+            if(_.end!=nil)
+                return _.end.elem;
+            return nil;
+        },
+    };
+}

stl/queue.nas

@@ -0,0 +1,46 @@
+# lib queue.nas
+# valkmjolnir 2021/3/31
+var queue=func()
+{
+    var _={begin:nil,end:nil};
+    return
+    {
+        push:func(elem)
+        {
+            var new_node=
+            {
+                elem:elem,
+                next:nil
+            };
+            if(_.begin==nil)
+                _.begin=_.end=new_node;
+            else
+            {
+                _.end.next=new_node;
+                _.end=new_node;
+            }
+            return;
+        },
+        pop:func()
+        {
+            if(_.begin!=nil)
+                _.begin=_.begin.next;
+            if(_.begin==nil)
+                _.end=nil;
+        },
+        front:func()
+        {
+            if(_.begin!=nil)
+                return _.begin.elem;
+            return nil;
+        },
+        clear:func()
+        {
+            _.begin=_.end=nil;
+        },
+        empty:func()
+        {
+            return _.begin==nil;
+        }
+    };
+}

stl/sort.nas

@@ -0,0 +1,27 @@
+# lib sort.nas
+# valkmjolnir 2021/4/2
+var sort=func(vec,left,right,cmp=func(a,b){return a<=b;})
+{
+    if(left>=right) return nil;
+    var L=left;
+    var R=right;
+    var tmp=vec[L];
+    while(left<right)
+    {
+        while(left<right and cmp(tmp,vec[right]))
+            right-=1;
+        while(left<right and cmp(vec[left],tmp))
+            left+=1;
+        if(left!=right)
+        {
+            var t=vec[left];
+            vec[left]=vec[right];
+            vec[right]=t;
+        }
+    }
+    vec[L]=vec[left];
+    vec[left]=tmp;
+    sort(vec,L,left-1,cmp);
+    sort(vec,left+1,R,cmp);
+    return nil;
+}

stl/stack.nas

@@ -0,0 +1,36 @@
+# lib stack.nas
+# valkmjolnir 2021/3/31
+var stack=func()
+{
+    var _={next:nil};
+    return
+    {
+        push:func(elem)
+        {
+            _.next={elem:elem,next:_.next};
+            return;
+        },
+        pop:func()
+        {
+            var tmp=_.next;
+            if(tmp!=nil)
+                _.next=tmp.next;
+            return;
+        },
+        top:func()
+        {
+            var tmp=_.next;
+            if(tmp!=nil)
+                return tmp.elem;
+            return nil;
+        },
+        clear:func()
+        {
+            _.next=nil;
+        },
+        empty:func()
+        {
+            return _.next==nil;
+        }
+    };
+}