From 362924c107ebc523525aea0c7e80c07465806737 Mon Sep 17 00:00:00 2001
From: Michael Nolan <tesses@tesses.net>
Date: Fri, 5 May 2023 23:03:12 -0500
Subject: [PATCH] Added ret, break and also rand

---
 libtlang/include/tlang.h            | 13 +++++++---
 libtlang/src/addnode.c              |  6 ++---
 libtlang/src/bitwiseand.c           |  6 ++---
 libtlang/src/bitwiseor.c            |  6 ++---
 libtlang/src/breaknode.c            | 21 ++++++++++++++++
 libtlang/src/bwnot.c                |  4 ++--
 libtlang/src/closurenode.c          |  2 +-
 libtlang/src/constnode.c            | 14 +++++------
 libtlang/src/dividenode.c           |  6 ++---
 libtlang/src/eachnode.c             | 10 ++++----
 libtlang/src/eq.c                   |  6 ++---
 libtlang/src/forloop.c              | 20 +++++++++-------
 libtlang/src/functioncallnode.c     |  5 ++--
 libtlang/src/getarraynode.c         | 13 ++++++----
 libtlang/src/getmembernode.c        |  9 ++++---
 libtlang/src/getvariablenode.c      |  2 +-
 libtlang/src/greaterthan.c          |  6 ++---
 libtlang/src/greaterthanequal.c     |  6 ++---
 libtlang/src/if.c                   |  6 ++---
 libtlang/src/leftshift.c            |  6 ++---
 libtlang/src/lessthan.c             |  6 ++---
 libtlang/src/lessthanequal.c        |  6 ++---
 libtlang/src/logicaland.c           |  6 ++---
 libtlang/src/logicalor.c            |  6 ++---
 libtlang/src/methodcallnode.c       | 37 ++++++++++++++++-------------
 libtlang/src/modulonode.c           |  6 ++---
 libtlang/src/multiplynode.c         |  6 ++---
 libtlang/src/neg.c                  |  4 ++--
 libtlang/src/neq.c                  |  6 ++---
 libtlang/src/not.c                  |  4 ++--
 libtlang/src/parser.c               |  8 +++++++
 libtlang/src/postfixdecrementnode.c |  6 ++---
 libtlang/src/postfixincrementnode.c |  7 +++---
 libtlang/src/rand.c                 | 35 +++++++++++++++++++++++++++
 libtlang/src/returnnode.c           | 22 +++++++++++++++++
 libtlang/src/rightshift.c           |  6 ++---
 libtlang/src/runtime.c              |  8 +++++--
 libtlang/src/scopenode.c            | 10 ++++++--
 libtlang/src/setvariablenode.c      |  4 ++--
 libtlang/src/subnode.c              |  6 ++---
 libtlang/src/tobject.c              |  5 +++-
 libtlang/src/whileloop.c            | 18 +++++++-------
 libtlang/src/xor.c                  |  6 ++---
 tlang/src/main.c                    |  2 +-
 wrappergen/Makefile                 |  1 +
 45 files changed, 261 insertions(+), 137 deletions(-)
 create mode 100644 libtlang/src/breaknode.c
 create mode 100644 libtlang/src/rand.c
 create mode 100644 libtlang/src/returnnode.c

diff --git a/libtlang/include/tlang.h b/libtlang/include/tlang.h
index 20982d6..5e40259 100644
--- a/libtlang/include/tlang.h
+++ b/libtlang/include/tlang.h
@@ -42,7 +42,12 @@ struct string {
             int length;
         };
 
-typedef tobject_t* (*node_exec_t)(node_t*,scope_t*);
+typedef struct 
+{
+    bool isReturning;
+    bool isBreaking;
+} retarg_t;
+typedef tobject_t* (*node_exec_t)(node_t*,scope_t*,retarg_t*);
 typedef void (*node_set_t)(node_t*,tobject_t*,scope_t*);
 typedef tobject_t* (*external_method_t)(runtime_t*,void* ptr,list_tobject_t* objs);
 typedef enum {tnull,tundef,tdict,texternalmethod,tinternalmethod,tlist,tstring,tnumber,tbool,tchar} tobject_type_t;
@@ -62,7 +67,7 @@ node_t* node_not_create(node_t* left);
 node_t* node_const_object_create(tobject_t*);
 node_t* node_postfix_decrement_create(node_t* left);
 node_t* node_postfix_increment_create(node_t* left);
-typedef enum {postfixincrementnode,postfixdecrementnode,methodcallnode,bnotnode,negnode,notnode,notequalsnode,equalsnode,whileloopnode,eachloopnode,forloopnode,ifnode,getarraynode,logicalornode,logicalandnode,xornode,closurenode,scopenode,bitwiseornode,bitwiseandnode,addnode,lessthannode,lessthanequalnode,greaterthannode,greaterthanequalnode,subnode,multiplynode,dividenode,modulonode,leftshiftnode,rightshiftnode,constobjectnode,constnumbernode,constnullnode,constundefnode,conststringnode,constboolnode,constcharnode,functioncallnode,setvariablenode,getvariablenode,getmembernode} node_type_t;
+typedef enum {postfixincrementnode,postfixdecrementnode,methodcallnode,bnotnode,negnode,notnode,notequalsnode,equalsnode,whileloopnode,eachloopnode,forloopnode,ifnode,getarraynode,logicalornode,logicalandnode,xornode,closurenode,scopenode,bitwiseornode,bitwiseandnode,addnode,lessthannode,lessthanequalnode,greaterthannode,greaterthanequalnode,subnode,multiplynode,dividenode,modulonode,leftshiftnode,rightshiftnode,constobjectnode,constnumbernode,constnullnode,constundefnode,conststringnode,constboolnode,constcharnode,functioncallnode,setvariablenode,getvariablenode,getmembernode,breaknode,returnnode} node_type_t;
 
 typedef struct {
     char* key;
@@ -455,4 +460,6 @@ void runtime_create_string_on_dict(dict_t* dict,char* name,runtime_t* rt,const c
 void runtime_create_method_on_object(tobject_t* tdict_obj,char* name,runtime_t* rt,void* ptr,external_method_t cb,texternalmethod_free_t free);
 void runtime_create_number_on_object(tobject_t* tdict_obj,char* name,runtime_t* rt,double number);
 void runtime_create_bool_on_object(tobject_t* tdict_obj,char* name,runtime_t* rt,bool value);
-void runtime_create_string_on_object(tobject_t* tdict_obj,char* name,runtime_t* rt,const char* text);
\ No newline at end of file
+void runtime_create_string_on_object(tobject_t* tdict_obj,char* name,runtime_t* rt,const char* text);
+node_t* node_break_create();
+node_t* node_return_create(node_t* arg);
\ No newline at end of file
diff --git a/libtlang/src/addnode.c b/libtlang/src/addnode.c
index abfc0bc..08a665a 100644
--- a/libtlang/src/addnode.c
+++ b/libtlang/src/addnode.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __add_node_exec(node_t* n,scope_t* sc)
+tobject_t* __add_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/bitwiseand.c b/libtlang/src/bitwiseand.c
index 1dd5187..c3264f0 100644
--- a/libtlang/src/bitwiseand.c
+++ b/libtlang/src/bitwiseand.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __bitwiseand_node_exec(node_t* n,scope_t* sc)
+tobject_t* __bitwiseand_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/bitwiseor.c b/libtlang/src/bitwiseor.c
index bf0443e..44f1949 100644
--- a/libtlang/src/bitwiseor.c
+++ b/libtlang/src/bitwiseor.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __bitwiseor_node_exec(node_t* n,scope_t* sc)
+tobject_t* __bitwiseor_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/breaknode.c b/libtlang/src/breaknode.c
new file mode 100644
index 0000000..05dbdab
--- /dev/null
+++ b/libtlang/src/breaknode.c
@@ -0,0 +1,21 @@
+#include "tlang.h"
+
+
+tobject_t* __break_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
+{
+   retArg->isBreaking=true;
+   return tobject_basic(sc->rt,tnull);
+}
+void __node_none_free(node_t* n)
+{
+
+}
+node_t* node_break_create()
+{
+    node_t* node = (node_t*)malloc(sizeof(node_t));
+    node->type = breaknode;
+    
+    node->execute = __break_node_exec;
+    node->free = __node_none_free;
+    return node;
+}
\ No newline at end of file
diff --git a/libtlang/src/bwnot.c b/libtlang/src/bwnot.c
index 805bd61..da059e4 100644
--- a/libtlang/src/bwnot.c
+++ b/libtlang/src/bwnot.c
@@ -1,12 +1,12 @@
 #include "tlang.h"
 
 extern void __node_single_free(node_t* n);
-tobject_t* __bwnot_node_exec(node_t* n,scope_t* sc)
+tobject_t* __bwnot_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
    
     node_t* left = n->data.single_node_node;
-    tobject_t* l=left->execute(left,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
    
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
diff --git a/libtlang/src/closurenode.c b/libtlang/src/closurenode.c
index cdd6c98..6b9901c 100644
--- a/libtlang/src/closurenode.c
+++ b/libtlang/src/closurenode.c
@@ -1,6 +1,6 @@
 #include "tlang.h"
 
-tobject_t* __closure_node_exec(node_t* n,scope_t* sc)
+tobject_t* __closure_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     tobject_t* c = tobject_create(sc->rt);
     c->type = tinternalmethod;
diff --git a/libtlang/src/constnode.c b/libtlang/src/constnode.c
index 3c7e735..28576ce 100644
--- a/libtlang/src/constnode.c
+++ b/libtlang/src/constnode.c
@@ -1,5 +1,5 @@
 #include "tlang.h"
-tobject_t* __const_number_exec(node_t* n,scope_t* sc)
+tobject_t* __const_number_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     tobject_t* obj=tobject_create(sc->rt);
     obj->data.number = n->data.const_number;
@@ -23,7 +23,7 @@ node_t* node_const_number_create(double num)
     n->free = __const_number_free;
     return n;
 }
-tobject_t* __const_bool_exec(node_t* n,scope_t* sc)
+tobject_t* __const_bool_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     tobject_t* obj=tobject_create(sc->rt);
     obj->data.boolean = n->data.const_bool;
@@ -31,7 +31,7 @@ tobject_t* __const_bool_exec(node_t* n,scope_t* sc)
     obj->type =tbool;
     return obj;
 }
-tobject_t* __const_string_exec(node_t* n,scope_t* sc)
+tobject_t* __const_string_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     tobject_t* obj=tobject_create(sc->rt);
     obj->data.string = string_dups(n->data.const_string);
@@ -39,7 +39,7 @@ tobject_t* __const_string_exec(node_t* n,scope_t* sc)
     obj->type =tstring;
     return obj;
 }
-tobject_t* __const_char_exec(node_t* n,scope_t* sc)
+tobject_t* __const_char_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     tobject_t* obj=tobject_create(sc->rt);
     obj->data.chr = n->data.const_char;
@@ -64,7 +64,7 @@ node_t* node_const_char_create(char c)
     n->free = __const_number_free;
     return n;
 }
-tobject_t* __const_object_exec(node_t* n,scope_t* sc)
+tobject_t* __const_object_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     return n->data.const_obj;
 }
@@ -86,7 +86,7 @@ node_t* node_const_bool_create(bool c)
     n->free = __const_number_free;
     return n;
 }
-tobject_t* __const_undef_exec(node_t* n,scope_t* s)
+tobject_t* __const_undef_exec(node_t* n,scope_t* s,retarg_t* retArg)
 {
     return tobject_basic(s->rt,tundef);
 }
@@ -99,7 +99,7 @@ node_t* node_const_undef_create()
     n->free = __const_number_free;
     return n;
 }
-tobject_t* __const_null_exec(node_t* n,scope_t* s)
+tobject_t* __const_null_exec(node_t* n,scope_t* s,retarg_t* retArg)
 {
     return tobject_basic(s->rt,tnull);
 }
diff --git a/libtlang/src/dividenode.c b/libtlang/src/dividenode.c
index e729cd7..42ac4ea 100644
--- a/libtlang/src/dividenode.c
+++ b/libtlang/src/dividenode.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __divide_node_exec(node_t* n,scope_t* sc)
+tobject_t* __divide_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/eachnode.c b/libtlang/src/eachnode.c
index be4eb24..946169e 100644
--- a/libtlang/src/eachnode.c
+++ b/libtlang/src/eachnode.c
@@ -1,21 +1,22 @@
 #include "tlang.h"
 extern tobject_t* last_ittr_loop(runtime_t* rt,void* ptr,list_tobject_t* obj);
-tobject_t* __each_loop_exec(node_t* n,scope_t* s)
+tobject_t* __each_loop_exec(node_t* n,scope_t* s,retarg_t* retArg)
 {
     tobject_t* ls=NULL;
     s=scope_begin(s);
     if(n->data.eachloop_node.ls != NULL)
-    ls= n->data.eachloop_node.ls->execute(n->data.eachloop_node.ls,s);
+    ls= n->data.eachloop_node.ls->execute(n->data.eachloop_node.ls,s,retArg);
     bool isRunning=true;
     s->setvariable(s,"last_ittr",tobject_fromexternalmethod(s->rt,&isRunning,last_ittr_loop,NULL));
     tobject_t* res = tobject_basic(s->rt,tundef);
     res->count=1;
+    retArg->isBreaking=false;
     if(ls != NULL)
     {
         ittr_t* ittr = ittr_obj(ls,s);
         if(ittr != NULL)
         {
-            while(ittr_movenext(ittr) && isRunning)
+            while(ittr_movenext(ittr) && isRunning && !retArg->isBreaking && !retArg->isReturning)
             {
                tobject_t* obj= ittr->getcurrent(ittr);
                if(n->data.eachloop_node.variable->type == getvariablenode || n->data.eachloop_node.variable->type == getmembernode)
@@ -26,7 +27,7 @@ tobject_t* __each_loop_exec(node_t* n,scope_t* s)
                {
                     n->data.eachloop_node.variable->data.array_node.set(n->data.eachloop_node.variable,obj,s);
                }
-               tobject_t* myRes=n->data.eachloop_node.body->execute(n->data.eachloop_node.body,s);
+               tobject_t* myRes=n->data.eachloop_node.body->execute(n->data.eachloop_node.body,s,retArg);
                tobject_addref(myRes);
                tobject_rmref(res);
                
@@ -36,6 +37,7 @@ tobject_t* __each_loop_exec(node_t* n,scope_t* s)
             ittr_free(ittr);
         }
     }
+    retArg->isBreaking=false;
     s=scope_end(s);
     tobject_freeifzero(ls);
     res->count--;
diff --git a/libtlang/src/eq.c b/libtlang/src/eq.c
index fd8ae44..2631a21 100644
--- a/libtlang/src/eq.c
+++ b/libtlang/src/eq.c
@@ -2,14 +2,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __eq_node_exec(node_t* n,scope_t* sc)
+tobject_t* __eq_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=tobject_same(sc->rt,l,r,&freeleftifzero);
     if(out != NULL) out->count++;
     if(freeleftifzero)
diff --git a/libtlang/src/forloop.c b/libtlang/src/forloop.c
index 304841b..214568b 100644
--- a/libtlang/src/forloop.c
+++ b/libtlang/src/forloop.c
@@ -7,39 +7,41 @@ tobject_t* last_ittr_loop(runtime_t* rt,void* ptr,list_tobject_t* obj)
     *flag=false;
     return tobject_bool(rt,true);
 }
-tobject_t* __loop_exec2(node_t* n,scope_t* s)
+tobject_t* __loop_exec2(node_t* n,scope_t* s,retarg_t* retArg)
 {
     if(n == NULL) return tobject_bool(s->rt,true);
-    return n->execute(n,s);
+    return n->execute(n,s,retArg);
 }
-bool __loop_bool(node_t* n,scope_t* s)
+bool __loop_bool(node_t* n,scope_t* s,retarg_t* retArg)
 {
-    tobject_t* o = __loop_exec2(n,s);
+    tobject_t* o = __loop_exec2(n,s,retArg);
     bool r = tobject_tobool(o);
     tobject_freeifzero(o);
     return r;
 }
-tobject_t* __for_loop_exec(node_t* a,scope_t* s)
+tobject_t* __for_loop_exec(node_t* a,scope_t* s,retarg_t* retArg)
 {
     //do for loop crap
     s=scope_begin(s);
     if(a->data.forloop_node.init != NULL)
-        tobject_freeifzero(a->data.forloop_node.init->execute(a->data.forloop_node.init,s));
+        tobject_freeifzero(a->data.forloop_node.init->execute(a->data.forloop_node.init,s,retArg));
     
     bool isRunning=true;
     s->setvariable(s,"last_ittr",tobject_fromexternalmethod(s->rt,&isRunning,last_ittr_loop,NULL));
     tobject_t* res = tobject_basic(s->rt,tundef);
     res->count=1;
-    while(__loop_bool(a->data.forloop_node.condition,s) && isRunning)
+    retArg->isBreaking=false;
+    while(__loop_bool(a->data.forloop_node.condition,s,retArg) && isRunning && !retArg->isBreaking && !retArg->isReturning)
     {
         
-        tobject_t* _r = __loop_exec2(a->data.forloop_node.body,s);
+        tobject_t* _r = __loop_exec2(a->data.forloop_node.body,s,retArg);
         tobject_addref(_r);
         tobject_rmref(res);
         res=_r;
 
-        __loop_bool(a->data.forloop_node.inc,s);
+        __loop_bool(a->data.forloop_node.inc,s,retArg);
     }
+    retArg->isBreaking=false;
    
     s=scope_end(s);
      res->count--;
diff --git a/libtlang/src/functioncallnode.c b/libtlang/src/functioncallnode.c
index 24bbb07..74de787 100644
--- a/libtlang/src/functioncallnode.c
+++ b/libtlang/src/functioncallnode.c
@@ -1,5 +1,5 @@
 #include "tlang.h"
-tobject_t* __node_function_call_execute(node_t* n,scope_t* s)
+tobject_t* __node_function_call_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     
     list_tobject_t args;
@@ -9,7 +9,8 @@ tobject_t* __node_function_call_execute(node_t* n,scope_t* s)
     for(i = 0;i< n->data.function_call_node.count;i++)
     {
         node_t* a =n->data.function_call_node.args[i];
-        list_add(&args,a->execute(a,s));
+        retarg_t retArg2;
+        list_add(&args,a->execute(a,s,&retArg2));
     }
     char* name = string_dupp(n->data.function_call_node.name);
     tobject_t* fname = s->getvariable(s,name);
diff --git a/libtlang/src/getarraynode.c b/libtlang/src/getarraynode.c
index c7e0977..c9d8a24 100644
--- a/libtlang/src/getarraynode.c
+++ b/libtlang/src/getarraynode.c
@@ -20,13 +20,13 @@ tobject_t* __kvp_as_str(tobject_t* parent_obj,tobject_t* argument_obj)
     return NULL;
 }
 
-tobject_t* __node_getarray_execute(node_t* n,scope_t* s)
+tobject_t* __node_getarray_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     node_t* parent=n->data.array_node.parent;
-    tobject_t* parent_obj = parent->execute(parent,s);
+    tobject_t* parent_obj = parent->execute(parent,s,retArg);
     tobject_t* o = NULL;
     node_t* argument =n->data.array_node.argument;
-    tobject_t* argument_obj = argument->execute(argument,s);
+    tobject_t* argument_obj = argument->execute(argument,s,retArg);
 
     if(parent_obj->type == tlist)
     {
@@ -115,10 +115,13 @@ void __kvp_set(tobject_t* parent_obj,tobject_t* argument_obj,tobject_t* variable
 void __node_setarray_execute(node_t* n,tobject_t* variable_obj,scope_t* s)
 {
     node_t* parent=n->data.array_node.parent;
-    tobject_t* parent_obj = parent->execute(parent,s);
+    retarg_t arg;
+    arg.isBreaking=false;
+    arg.isReturning=false;
+    tobject_t* parent_obj = parent->execute(parent,s,&arg);
     
     node_t* argument =n->data.array_node.argument;
-    tobject_t* argument_obj = argument->execute(argument,s);
+    tobject_t* argument_obj = argument->execute(argument,s,&arg);
 
     if(parent_obj->type == tlist)
     {
diff --git a/libtlang/src/getmembernode.c b/libtlang/src/getmembernode.c
index 0201cfb..e4ad6a9 100644
--- a/libtlang/src/getmembernode.c
+++ b/libtlang/src/getmembernode.c
@@ -31,10 +31,10 @@ tobject_t* __ls_free(runtime_t* rt,void* ptr,list_tobject_t* ls)
      return tobject_basic(rt,tnull);
 
 }
-tobject_t* __node_getmember_execute(node_t* n,scope_t* s)
+tobject_t* __node_getmember_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     node_t* parent=n->data.variable_node.parent;
-    tobject_t* parent_obj = parent->execute(parent,s);
+    tobject_t* parent_obj = parent->execute(parent,s,retArg);
 
     char* vn = string_dupp(n->data.variable_node.name);
     string_t* getvars = string_create();
@@ -166,7 +166,10 @@ void __node_setmember_execute(node_t* n,tobject_t* o,scope_t* s)
 {
     node_t* parent=n->data.variable_node.parent;
     //node_t* myN = n->data.variable_node.value;
-    tobject_t* parent_obj = parent->execute(parent,s);
+    retarg_t arg;
+    arg.isBreaking=false;
+    arg.isReturning=false;
+    tobject_t* parent_obj = parent->execute(parent,s,&arg);
 
     char* vn = string_dupp(n->data.variable_node.name);
     string_t* getvars = string_create();
diff --git a/libtlang/src/getvariablenode.c b/libtlang/src/getvariablenode.c
index 177634b..1353804 100644
--- a/libtlang/src/getvariablenode.c
+++ b/libtlang/src/getvariablenode.c
@@ -1,5 +1,5 @@
 #include "tlang.h"
-tobject_t* __node_getvariable_execute(node_t* n,scope_t* s)
+tobject_t* __node_getvariable_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     char* vn = string_dupp(n->data.variable_node.name);
     
diff --git a/libtlang/src/greaterthan.c b/libtlang/src/greaterthan.c
index d5a9b49..06f93e4 100644
--- a/libtlang/src/greaterthan.c
+++ b/libtlang/src/greaterthan.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __greaterthan_node_exec(node_t* n,scope_t* sc)
+tobject_t* __greaterthan_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/greaterthanequal.c b/libtlang/src/greaterthanequal.c
index 8f43753..62467d1 100644
--- a/libtlang/src/greaterthanequal.c
+++ b/libtlang/src/greaterthanequal.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __greaterthanequal_node_exec(node_t* n,scope_t* sc)
+tobject_t* __greaterthanequal_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/if.c b/libtlang/src/if.c
index bcdd173..95f530f 100644
--- a/libtlang/src/if.c
+++ b/libtlang/src/if.c
@@ -1,12 +1,12 @@
 #include "tlang.h"
 extern bool __loop_bool(node_t* n,scope_t* s);
-tobject_t* __if_exec(node_t* n,scope_t* s)
+tobject_t* __if_exec(node_t* n,scope_t* s,retarg_t* retArg)
 {
     if(__loop_bool(n->data.if_node.condition,s))
     {
-        return n->data.if_node.yes->execute(n->data.if_node.yes,s);
+        return n->data.if_node.yes->execute(n->data.if_node.yes,s,retArg);
     } else {
-        return n->data.if_node.no->execute(n->data.if_node.no,s);
+        return n->data.if_node.no->execute(n->data.if_node.no,s,retArg);
     }
 }
 void __if_free(node_t* n)
diff --git a/libtlang/src/leftshift.c b/libtlang/src/leftshift.c
index 5890642..308aba2 100644
--- a/libtlang/src/leftshift.c
+++ b/libtlang/src/leftshift.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 #include <stdint.h>
 extern void __node_two_free(node_t* n);
-tobject_t* __leftshift_node_exec(node_t* n,scope_t* sc)
+tobject_t* __leftshift_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/lessthan.c b/libtlang/src/lessthan.c
index 29cb843..970b4aa 100644
--- a/libtlang/src/lessthan.c
+++ b/libtlang/src/lessthan.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __lessthan_node_exec(node_t* n,scope_t* sc)
+tobject_t* __lessthan_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/lessthanequal.c b/libtlang/src/lessthanequal.c
index bdcb653..68dcbe9 100644
--- a/libtlang/src/lessthanequal.c
+++ b/libtlang/src/lessthanequal.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __lessthanequal_node_exec(node_t* n,scope_t* sc)
+tobject_t* __lessthanequal_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/logicaland.c b/libtlang/src/logicaland.c
index 0c302f5..09d3832 100644
--- a/libtlang/src/logicaland.c
+++ b/libtlang/src/logicaland.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __logicaland_node_exec(node_t* n,scope_t* sc)
+tobject_t* __logicaland_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/logicalor.c b/libtlang/src/logicalor.c
index eb08080..3da7058 100644
--- a/libtlang/src/logicalor.c
+++ b/libtlang/src/logicalor.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __logicalor_node_exec(node_t* n,scope_t* sc)
+tobject_t* __logicalor_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/methodcallnode.c b/libtlang/src/methodcallnode.c
index 38133f6..b231a92 100644
--- a/libtlang/src/methodcallnode.c
+++ b/libtlang/src/methodcallnode.c
@@ -2,10 +2,10 @@
 #include <ctype.h>
 #include <stdint.h>
 #include <math.h>
-tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
+tobject_t* __node_method_call_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     node_t* parent=n->data.variable_node.parent;
-    tobject_t* parent_obj = parent->execute(parent,s);
+    tobject_t* parent_obj = parent->execute(parent,s,retArg);
      tobject_t* o=NULL;
      char* name = string_dupp(n->data.function_call_node.name);
      
@@ -22,7 +22,10 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
     for(i = 0;i< n->data.function_call_node.count;i++)
     {
         node_t* a =n->data.function_call_node.args[i];
-        list_add(&args,a->execute(a,s));
+        retarg_t _arg;
+        _arg.isBreaking=false;
+        _arg.isReturning=false;
+        list_add(&args,a->execute(a,s,&_arg));
     }
 
     o = tobject_call(s,fname,&args);
@@ -78,8 +81,8 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 2)
             {
-                tobject_t* a0=args[0]->execute(args[0],s);
-                tobject_t* a1=args[1]->execute(args[1],s);
+                tobject_t* a0=args[0]->execute(args[0],s,retArg);
+                tobject_t* a1=args[1]->execute(args[1],s,retArg);
                 string_t* s1=tobject_tostring(s,a0);
                 string_t* s2=tobject_tostring(s,a1);
                 
@@ -94,7 +97,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
             if(argcount >= 1)
             {
                 
-                tobject_t* sOn=args[0]->execute(args[0],s);
+                tobject_t* sOn=args[0]->execute(args[0],s,retArg);
                 
                 string_t* splitOn=tobject_tostring(s,sOn);
                 int count = 2147483647;
@@ -103,14 +106,14 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
 
                 if(argcount >= 2)
                 {
-                    tobject_t* sOn=args[1]->execute(args[1],s);
+                    tobject_t* sOn=args[1]->execute(args[1],s,retArg);
                     
                     splitOp = tobject_tobool(sOn);
                     //tobject_freeifzero(sOn);
                 }
                 if(argcount >= 3)
                 {
-                    tobject_t* _count=args[2]->execute(args[2],s);
+                    tobject_t* _count=args[2]->execute(args[2],s,retArg);
                     if(_count->type == tnumber)
                     {
                         count =  (int)_count->data.number;
@@ -128,7 +131,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 1)
             {
-                tobject_t* sOn=args[0]->execute(args[0],s);
+                tobject_t* sOn=args[0]->execute(args[0],s,retArg);
                 
                 string_t* starts=tobject_tostring(s,sOn);
                 o = tobject_bool(s->rt,string_startswith(parent_obj->data.string,starts));
@@ -140,7 +143,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 1)
             {
-                tobject_t* sOn=args[0]->execute(args[0],s);
+                tobject_t* sOn=args[0]->execute(args[0],s,retArg);
                 
                 string_t* starts=tobject_tostring(s,sOn);
                 o = tobject_bool(s->rt,string_endswith(parent_obj->data.string,starts));
@@ -157,7 +160,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
             char c = ' ';
             if(argcount >= 1)
             {
-            tobject_t* sOn=args[0]->execute(args[0],s);
+            tobject_t* sOn=args[0]->execute(args[0],s,retArg);
             if(sOn->type == tchar)
             {
                 c = sOn->data.chr;
@@ -174,7 +177,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
             char c = ' ';
             if(argcount >= 1)
             {
-            tobject_t* sOn=args[0]->execute(args[0],s);
+            tobject_t* sOn=args[0]->execute(args[0],s,retArg);
             if(sOn->type == tchar)
             {
                 c = sOn->data.chr;
@@ -224,7 +227,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 1)
             {
-                tobject_t* o2=args[0]->execute(args[0],s);
+                tobject_t* o2=args[0]->execute(args[0],s,retArg);
                 
                 list_add(&parent_obj->data.list,o2);
                 o=parent_obj;
@@ -234,7 +237,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 1)
             {
-                tobject_t* o2=args[0]->execute(args[0],s);
+                tobject_t* o2=args[0]->execute(args[0],s,retArg);
                 
                 list_remove(&parent_obj->data.list,o2);
                 o=parent_obj;
@@ -244,7 +247,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
         {
             if(argcount >= 1)
             {
-                tobject_t* o2=args[0]->execute(args[0],s);
+                tobject_t* o2=args[0]->execute(args[0],s,retArg);
                 if(o2->type != tnumber)
                 {
                     int index=(int)o2->data.number;
@@ -262,7 +265,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
             tobject_t* val = NULL;
             if(argcount >= 2)
             {
-                val = args[1]->execute(args[1],s);
+                val = args[1]->execute(args[1],s,retArg);
                 o=val;
             }
             else if(argcount == 1) 
@@ -272,7 +275,7 @@ tobject_t* __node_method_call_execute(node_t* n,scope_t* s)
             }
             if(argcount >= 1)
             {
-                tobject_t* o2=args[0]->execute(args[0],s);
+                tobject_t* o2=args[0]->execute(args[0],s,retArg);
                 if(o2->type != tnumber)
                 {
                     int index=(int)o2->data.number;
diff --git a/libtlang/src/modulonode.c b/libtlang/src/modulonode.c
index 7a35628..efbb8a1 100644
--- a/libtlang/src/modulonode.c
+++ b/libtlang/src/modulonode.c
@@ -2,14 +2,14 @@
 #include <math.h>
 
 extern void __node_two_free(node_t* n);
-tobject_t* __modulo_node_exec(node_t* n,scope_t* sc)
+tobject_t* __modulo_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/multiplynode.c b/libtlang/src/multiplynode.c
index 94fd0d1..a205367 100644
--- a/libtlang/src/multiplynode.c
+++ b/libtlang/src/multiplynode.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __multiply_node_exec(node_t* n,scope_t* sc)
+tobject_t* __multiply_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/neg.c b/libtlang/src/neg.c
index 0a271b8..c7b5a1e 100644
--- a/libtlang/src/neg.c
+++ b/libtlang/src/neg.c
@@ -1,11 +1,11 @@
 #include "tlang.h"
 
 extern void __node_single_free(node_t* n);
-tobject_t* __neg_node_exec(node_t* n,scope_t* sc)
+tobject_t* __neg_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     node_t* left = n->data.single_node_node;
-   tobject_t* l=left->execute(left,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
     
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
diff --git a/libtlang/src/neq.c b/libtlang/src/neq.c
index 39cc0a4..97b01f5 100644
--- a/libtlang/src/neq.c
+++ b/libtlang/src/neq.c
@@ -2,14 +2,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __neq_node_exec(node_t* n,scope_t* sc)
+tobject_t* __neq_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/not.c b/libtlang/src/not.c
index 5f5f6c1..d7ba134 100644
--- a/libtlang/src/not.c
+++ b/libtlang/src/not.c
@@ -4,12 +4,12 @@ void __node_single_free(node_t* n)
 {
     node_free(n->data.single_node_node);
 }
-tobject_t* __not_node_exec(node_t* n,scope_t* sc)
+tobject_t* __not_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.single_node_node;
-    tobject_t* l=left->execute(left,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
    
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
diff --git a/libtlang/src/parser.c b/libtlang/src/parser.c
index 0114268..6a96308 100644
--- a/libtlang/src/parser.c
+++ b/libtlang/src/parser.c
@@ -376,6 +376,14 @@ node_t* parse_value(parser_t* p)
         }
         return node_const_char_create(c);
     }
+    if(string_samep(token.text,"brk") || string_samep(token.text,"break"))
+    {
+        return node_break_create();
+    }
+    if(string_samep(token.text,"ret") || string_samep(token.text,"return"))
+    {
+        return node_return_create(parse_expression(p));
+    }
     if(string_samep(token.text,"-"))
     {
         
diff --git a/libtlang/src/postfixdecrementnode.c b/libtlang/src/postfixdecrementnode.c
index 15433f2..2e28fbb 100644
--- a/libtlang/src/postfixdecrementnode.c
+++ b/libtlang/src/postfixdecrementnode.c
@@ -1,13 +1,13 @@
 #include "tlang.h"
 
 extern void __node_single_free(node_t* n);
-tobject_t* __postdec_node_exec(node_t* n,scope_t* sc)
+tobject_t* __postdec_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.single_node_node;
     
-    tobject_t* l=left->execute(left,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
    
     tobject_t* out=NULL;
     
@@ -15,7 +15,7 @@ tobject_t* __postdec_node_exec(node_t* n,scope_t* sc)
     l->count++;
     node_t* n3=node_setvariable_create(left,node_sub_create(node_const_object_create(l),node_const_number_create(1)),true);
    
-    n3->execute(n3,sc);
+    n3->execute(n3,sc,retArg);
 
      n3->data.two_node_node.left = node_const_number_create(0);
     node_free(n3);
diff --git a/libtlang/src/postfixincrementnode.c b/libtlang/src/postfixincrementnode.c
index c512409..167f63d 100644
--- a/libtlang/src/postfixincrementnode.c
+++ b/libtlang/src/postfixincrementnode.c
@@ -1,13 +1,13 @@
 #include "tlang.h"
 
 extern void __node_single_free(node_t* n);
-tobject_t* __postinc_node_exec(node_t* n,scope_t* sc)
+tobject_t* __postinc_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.single_node_node;
     
-    tobject_t* l=left->execute(left,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
    
     tobject_t* out=NULL;
     
@@ -16,7 +16,8 @@ tobject_t* __postinc_node_exec(node_t* n,scope_t* sc)
     
     node_t* n3=node_setvariable_create(left,node_add_create(node_const_object_create(l),node_const_number_create(1)),true);
     
-    n3->execute(n3,sc);
+    
+    n3->execute(n3,sc,retArg);
     
      n3->data.two_node_node.left = node_const_number_create(0);
     node_free(n3);
diff --git a/libtlang/src/rand.c b/libtlang/src/rand.c
new file mode 100644
index 0000000..fc9f4ce
--- /dev/null
+++ b/libtlang/src/rand.c
@@ -0,0 +1,35 @@
+#include "tlang.h"
+#include <stdlib.h>
+#include <stdint.h>
+
+tobject_t* rand_getnext_external_function(runtime_t* rt,void* ptr,list_tobject_t* args)
+{
+if(args->length >= 0)
+{
+double _res = (double)rand();
+return tobject_number(rt,_res);
+}
+return tobject_basic(rt,tnull);
+}
+tobject_t* rand_setseed_external_function(runtime_t* rt,void* ptr,list_tobject_t* args)
+{
+if(args->length >= 1 && (args->items[0]->type == tnumber || args->items[0]->type == tnull))
+{
+int _arg0 = (int)args->items[0]->data.number;
+srand(_arg0);
+
+
+}
+return tobject_basic(rt,tnull);
+}
+
+void runtime_register_rand(runtime_t* rt)
+{
+tobject_t* _rand = tobject_create(rt);
+_rand->type = tdict;
+_rand->data.dict = dict_create();
+runtime_create_method_on_dict(_rand->data.dict,"getnext",rt,NULL,rand_getnext_external_function,NULL);
+runtime_create_method_on_dict(_rand->data.dict,"setseed",rt,NULL,rand_setseed_external_function,NULL);
+
+rt->globals->setvariable(rt->globals,"rand",_rand);
+}
diff --git a/libtlang/src/returnnode.c b/libtlang/src/returnnode.c
new file mode 100644
index 0000000..b33c92e
--- /dev/null
+++ b/libtlang/src/returnnode.c
@@ -0,0 +1,22 @@
+#include "tlang.h"
+
+extern void __node_single_free(node_t*);
+
+tobject_t* __return_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
+{
+    node_t* left = n->data.single_node_node;
+    tobject_t* l=left->execute(left,sc,retArg);
+   
+   retArg->isReturning=true;
+   return l;
+}
+
+node_t* node_return_create(node_t* arg)
+{
+    node_t* node = (node_t*)malloc(sizeof(node_t));
+    node->type = returnnode;
+    node->data.single_node_node = arg;
+    node->execute = __return_node_exec;
+    node->free = __node_single_free;
+    return node;
+}
\ No newline at end of file
diff --git a/libtlang/src/rightshift.c b/libtlang/src/rightshift.c
index 9a94436..1e092be 100644
--- a/libtlang/src/rightshift.c
+++ b/libtlang/src/rightshift.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 #include <stdint.h>
 extern void __node_two_free(node_t* n);
-tobject_t* __rightshift_node_exec(node_t* n,scope_t* sc)
+tobject_t* __rightshift_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/runtime.c b/libtlang/src/runtime.c
index 487c480..9afc0f9 100644
--- a/libtlang/src/runtime.c
+++ b/libtlang/src/runtime.c
@@ -281,7 +281,10 @@ tobject_t* __execute_code_rt(runtime_t* rt,void* ptr,list_tobject_t* args)
 }
 tobject_t* runtime_exec(runtime_t* rt)
 {
-    tobject_t* o = rt->program->execute(rt->program,rt->globals);
+    retarg_t _arg;
+    _arg.isBreaking=false;
+    _arg.isReturning=false;
+    tobject_t* o = rt->program->execute(rt->program,rt->globals,&_arg);
     if(rt->globals->hasvariable(rt->globals,"main"))
     {
         tobject_t* myObj=rt->globals->getvariable(rt->globals,"main");
@@ -838,6 +841,7 @@ void runtime_register(runtime_t* rt,runtime_reg_t reg)
     rt->reg = reg;
     reg(rt);
 }
+extern void runtime_register_rand(runtime_t* rt);
 
 void runtime_register_std(runtime_t* rt)
 {
@@ -925,7 +929,7 @@ void runtime_register_std(runtime_t* rt)
     #if defined(USE_MBED)
     runtime_register_mbed(rt);
     #endif
-    
+    runtime_register_rand(rt);
 }
 
 runtime_t* runtime_init()
diff --git a/libtlang/src/scopenode.c b/libtlang/src/scopenode.c
index 094c5f5..e4c2115 100644
--- a/libtlang/src/scopenode.c
+++ b/libtlang/src/scopenode.c
@@ -1,5 +1,5 @@
 #include "tlang.h"
-tobject_t* __node_scope_execute(node_t* n,scope_t* s)
+tobject_t* __node_scope_execute(node_t* n,scope_t* s,retarg_t* retArg)
 {
     if(n->data.scope_node.isSub)
     {
@@ -8,12 +8,18 @@ tobject_t* __node_scope_execute(node_t* n,scope_t* s)
     tobject_t* obj_data = tobject_basic(s->rt,tnull);
     tobject_addref(obj_data);
     int i;
+    
+
     for(i=0;i<n->data.scope_node.count;i++)
     {
-        tobject_t* d=n->data.scope_node.items[i]->execute(n->data.scope_node.items[i],s);
+        tobject_t* d=n->data.scope_node.items[i]->execute(n->data.scope_node.items[i],s,retArg);
         tobject_addref(d); 
         tobject_rmref(obj_data);
         obj_data=d;
+        if(retArg->isBreaking || retArg->isReturning)
+        {
+            break;
+        }
     }
     if(n->data.scope_node.isSub)
     {
diff --git a/libtlang/src/setvariablenode.c b/libtlang/src/setvariablenode.c
index 9841d8d..e74f1d8 100644
--- a/libtlang/src/setvariablenode.c
+++ b/libtlang/src/setvariablenode.c
@@ -1,10 +1,10 @@
 #include "tlang.h"
 
-tobject_t* _node_setvariable_exec(node_t* n,scope_t* sc)
+tobject_t* _node_setvariable_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     node_t* left=n->data.variable_set_node.variable;
     node_t* right = n->data.variable_set_node.value;
-    tobject_t* o = right->execute(right,sc);
+    tobject_t* o = right->execute(right,sc,retArg);
     o->count++;
     if(left->type == getarraynode)
     {
diff --git a/libtlang/src/subnode.c b/libtlang/src/subnode.c
index bfa5b88..44da71c 100644
--- a/libtlang/src/subnode.c
+++ b/libtlang/src/subnode.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __sub_node_exec(node_t* n,scope_t* sc)
+tobject_t* __sub_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/libtlang/src/tobject.c b/libtlang/src/tobject.c
index 8f62b55..6767fdc 100644
--- a/libtlang/src/tobject.c
+++ b/libtlang/src/tobject.c
@@ -300,7 +300,10 @@ tobject_t* tobject_call(scope_t* scope,tobject_t* func,list_tobject_t* args)
                 }
 
             }
-        res=func->data.internal_method.closure->data.closure_node.node->execute(func->data.internal_method.closure->data.closure_node.node,scope2);
+        retarg_t _arg;
+        _arg.isBreaking=false;
+        _arg.isReturning=false;    
+        res=func->data.internal_method.closure->data.closure_node.node->execute(func->data.internal_method.closure->data.closure_node.node,scope2,&_arg);
         scope_end(scope2);
         return res;
     }
diff --git a/libtlang/src/whileloop.c b/libtlang/src/whileloop.c
index 1cb6600..70f57aa 100644
--- a/libtlang/src/whileloop.c
+++ b/libtlang/src/whileloop.c
@@ -1,8 +1,8 @@
 #include "tlang.h"
-extern tobject_t* __loop_exec2(node_t* n,scope_t* s);
-extern bool __loop_bool(node_t* n,scope_t* s);
+extern tobject_t* __loop_exec2(node_t* n,scope_t* s,retarg_t* retArg);
+extern bool __loop_bool(node_t* n,scope_t* s,retarg_t* retArg);
 extern tobject_t* last_ittr_loop(runtime_t* rt,void* ptr,list_tobject_t* obj);
-node_t* __while_loop_exec(node_t* n,scope_t* s)
+node_t* __while_loop_exec(node_t* n,scope_t* s,retarg_t* retArg)
 {
     bool isRunning=true;
      s=scope_begin(s);
@@ -13,19 +13,21 @@ node_t* __while_loop_exec(node_t* n,scope_t* s)
     res->count=1;
     if(!n->data.whileloop_node.isDoLoop)
     {
-        isRunning = __loop_bool(n->data.whileloop_node.condition,s);
+        isRunning = __loop_bool(n->data.whileloop_node.condition,s,retArg);
     }
-    while(isRunning)
+    retArg->isBreaking=false;
+    while(isRunning && !retArg->isBreaking && !retArg->isReturning)
     {
-        tobject_t* _r = __loop_exec2(n->data.whileloop_node.body,s);
+        tobject_t* _r = __loop_exec2(n->data.whileloop_node.body,s,retArg);
         tobject_addref(_r);
         tobject_rmref(res);
         res=_r;
-        if(isRunning)
+        if(isRunning && !retArg->isBreaking && !retArg->isReturning)
         {
-            isRunning = __loop_bool(n->data.whileloop_node.condition,s);
+            isRunning = __loop_bool(n->data.whileloop_node.condition,s,retArg);
         }
     }
+    retArg->isBreaking=false;
     s=scope_end(s);
     res->count--;
     return res;
diff --git a/libtlang/src/xor.c b/libtlang/src/xor.c
index 8743824..f647d1f 100644
--- a/libtlang/src/xor.c
+++ b/libtlang/src/xor.c
@@ -1,14 +1,14 @@
 #include "tlang.h"
 
 extern void __node_two_free(node_t* n);
-tobject_t* __xor_node_exec(node_t* n,scope_t* sc)
+tobject_t* __xor_node_exec(node_t* n,scope_t* sc,retarg_t* retArg)
 {
     bool freeleftifzero=true;
     
     node_t* left = n->data.two_node_node.left;
     node_t* right = n->data.two_node_node.right;
-    tobject_t* l=left->execute(left,sc);
-    tobject_t* r=right->execute(right,sc);
+    tobject_t* l=left->execute(left,sc,retArg);
+    tobject_t* r=right->execute(right,sc,retArg);
     tobject_t* out=NULL;
     tobject_type_t ltype=l->type;
     tobject_type_t rtype =r->type;
diff --git a/tlang/src/main.c b/tlang/src/main.c
index 8702458..c690f58 100644
--- a/tlang/src/main.c
+++ b/tlang/src/main.c
@@ -26,7 +26,7 @@ int main(int argc,char** argv)
             }
             if(string_samep(cmd,"exit")) break;
             runtime_load(rt,cmd);
-            tobject_t* o = rt->program->execute(rt->program,rt->globals);
+            tobject_t* o = runtime_exec(rt);
             tobject_freeifzero(o);
             node_free(rt->program);
             rt->program=NULL;
diff --git a/wrappergen/Makefile b/wrappergen/Makefile
index 419048f..5bedf90 100644
--- a/wrappergen/Makefile
+++ b/wrappergen/Makefile
@@ -5,6 +5,7 @@ build-tlang-external:
 	tlang src/wrappergen.tlang src/data.txt dest --external
 sdl:
 	tlang src/wrappergen.tlang src/sdl.txt wrappers --omit
+
 PHONY: install
 install: sdl
 	cp wrappers/sdl.c ../libtlang/src/sdl2.c ; true