Add fetchcontent fixes for SDL2

CMakeLists.txt

@@ -189,6 +189,9 @@ CROSSLANG_LINK_DEPS(crosslang_static)
 if(CROSSLANG_FETCHCONTENT)
 
 target_link_libraries(crosslang_static PUBLIC tessesframework)
+if(TESSESFRAMEWORK_FETCHCONTENT AND TESSESFRAMEWORK_ENABLE_SDL2)
+sdl2_fix(crosslang_static)
+endif()
 else()
 target_link_libraries(crosslang_static PUBLIC TessesFramework::tessesframework)
 endif()
@@ -202,6 +205,9 @@ add_library(crosslang_shared SHARED ${CROSSLANG_SOURCE})
 CROSSLANG_LINK_DEPS(crosslang_shared)
 if(CROSSLANG_FETCHCONTENT)
 target_link_libraries(crosslang_shared PUBLIC tessesframework_shared)
+if(TESSESFRAMEWORK_FETCHCONTENT AND TESSESFRAMEWORK_ENABLE_SDL2)
+sdl2_fix(crosslang_shared)
+endif()
 else()
 target_link_libraries(crosslang_shared PUBLIC TessesFramework::tessesframework_shared)
 endif()

src/runtime_methods/sdl2.cpp

@@ -3,10 +3,9 @@
 #include "CrossLang.hpp"
 #include <iostream>
 #if defined(TESSESFRAMEWORK_ENABLE_SDL2)
-#include <SDL2/SDL.h>
+#include <TessesFramework/SDL2/SDL_Headers.hpp>
-#include <SDL2/SDL_ttf.h>
-#include <SDL2/SDL_image.h>
 #include <TessesFramework/SDL2/GUI.hpp>
+#include <TessesFramework/SDL2/Stream.hpp>
 #include <TessesFramework/SDL2/Views/AbsoluteView.hpp>
 #include <TessesFramework/SDL2/Views/ButtonView.hpp>
 #include <TessesFramework/SDL2/Views/LabelView.hpp>
@@ -1251,4 +1250,4 @@ namespace Tesses::CrossLang
 
         #endif
     }
-}
+}

src/types/async.cpp

@@ -0,0 +1,261 @@
+#include "CrossLang.hpp"
+//THANKS TO https://www.youtube.com/watch?v=R-z2Hv-7nxk
+namespace Tesses::CrossLang {
+    TTask::TTask(GC* gc)
+    {
+        this->gc = gc;
+    }
+    TTask* TTask::Create(GCList& ls)
+    {
+        TTask* task = new TTask(ls.GetGC());
+        ls.Add(task);
+        task->gc->Watch(task);
+        return task;
+    }
+    bool TTask::IsCompleted()
+    {
+        gc->BarrierBegin();
+        bool r = this->isCompleted;
+        gc->BarrierEnd();
+
+        return r;
+    }
+    TTask* TTask::ContinueWith(GCList& ls, TCallable* callable)
+    {
+        TTask* task = TTask::Create(ls);
+
+        TExternalMethod* em = TExternalMethod::Create(ls,"Internal async thing",{"_asyncObj"},[callable,task](GCList& ls,std::vector<TObject> args)->TObject{
+            try {
+                task->SetSucceeded(callable->Call(ls,args));
+            } catch(...) {
+                task->SetFailed(std::current_exception());
+            }
+            return nullptr;
+        });
+        em->watch = {callable,task};
+        
+        this->gc->BarrierBegin();
+        if(this->isCompleted)
+        {
+            this->gc->BarrierEnd();
+            std::shared_ptr<GCList> ls=std::make_shared<GCList>(gc);
+            auto cobj = this->obj;
+            ls->Add(cobj);
+            ls->Add(em);
+            this->gc->GetPool()->Schedule([ls,em,cobj](size_t s)->void {
+                em->Call(*ls,{cobj});
+            });
+            return task;
+        }
+        else 
+        {
+            this->cont = em;
+        }
+
+        this->gc->BarrierEnd();
+        return task;
+    }
+    void TTask::ContinueWith(TCallable* callable)
+    {
+        this->gc->BarrierBegin();
+        if(this->isCompleted)
+        {
+            this->gc->BarrierEnd();
+            std::shared_ptr<GCList> ls=std::make_shared<GCList>(gc);
+            auto cobj = this->obj;
+            ls->Add(cobj);
+            ls->Add(callable);
+            this->gc->GetPool()->Schedule([ls,callable,cobj](size_t s)->void {
+                callable->Call(*ls,{cobj});
+                
+            });
+            return;
+        }
+        else 
+        {
+            this->cont = callable;
+        }
+
+        this->gc->BarrierEnd();
+    }
+
+   
+
+
+    void TTask::SetFailed(std::exception_ptr ex)
+    {
+        this->ex = ex;
+        this->SetSucceeded(nullptr);
+    }
+    void TTask::SetSucceeded(TObject v)
+    {
+        gc->BarrierBegin();
+        if(this->isCompleted)
+        {
+            gc->BarrierEnd();
+            return;
+        }
+        this->isCompleted=true;
+        this->obj = v;
+        auto cont = this->cont;
+        gc->BarrierEnd();
+        if(cont != nullptr)
+        {
+            std::shared_ptr<GCList> ls=std::make_shared<GCList>(gc);
+            
+            auto callable = cont;
+            ls->Add(v);
+            ls->Add(callable);
+            this->gc->GetPool()->Schedule([ls,callable,v](size_t s)->void {
+                callable->Call(*ls,{v});
+            });
+        }
+    }
+
+    TObject TTask::Wait()
+    {
+        while(true)
+        {
+            gc->BarrierBegin();
+            if(this->isCompleted)
+            {
+                if(this->ex)
+                {
+                    auto error = this->ex;
+                    gc->BarrierEnd();
+                    std::rethrow_exception(error);
+                }
+                
+                auto o = this->obj;
+                gc->BarrierEnd();
+                return o;
+                
+            }
+            gc->BarrierEnd();
+        }
+    }
+    void TTask::Mark()
+    {
+        if(this->marked) return;
+        this->marked=true;
+        GC::Mark(this->obj);
+        if(this->cont != nullptr)
+            this->cont->Mark();
+    }
+
+    TTask* TTask::Run(GCList& ls, TCallable* callable)
+    {
+        TTask* task = TTask::Create(ls);
+        std::shared_ptr<GCList> ls2=std::make_shared<GCList>(ls.GetGC());
+        ls2->Add(callable);
+        ls2->Add(task);
+
+        ls.GetGC()->GetPool()->Schedule([ls2,callable,task](size_t s)->void {
+                try
+                {
+                    task->SetSucceeded(callable->Call(*ls2,{}));
+                } 
+                catch(...)
+                {
+                    task->SetFailed(std::current_exception());
+                }
+        });
+
+        return task;
+    }
+
+    TTask* TTask::FromResult(GCList& ls, TObject v)
+    {
+        TTask* task = TTask::Create(ls);
+        task->SetSucceeded(v);
+        return task;
+    }
+
+    class TTaskCseObj {
+        GC* gc;
+        TTask* task;
+        public:
+            TTaskCseObj(GC* gc, TTask* task)
+            {
+                this->gc = gc;
+                this->task = task;
+            }
+
+            void Invoke(std::shared_ptr<TTaskCseObj> shared_o,CallStackEntry* cse, TObject o)
+            {
+                try {
+                GCList ls(gc);
+                cse->Push(gc,o);
+                auto res = cse->Resume(ls);
+                CallStackEntry* cse2;
+                if(GetObjectHeap(res,cse2))
+                {
+                    auto taskPiece=cse2->Pop(ls);
+                    TTask* task;
+                    if(GetObjectHeap(taskPiece,task))
+                    {
+                        auto em = TExternalMethod::Create(ls,"",{"obj"},[cse2,task,shared_o](GCList& ls, std::vector<TObject> args)->TObject {
+                    
+                            shared_o->Invoke(shared_o,cse2,args.empty() ? (TObject)Undefined():args[0]);
+
+                            return nullptr;
+                        });
+                        em->watch.push_back(task);
+                        em->watch.push_back(cse2);
+               
+                        task->ContinueWith(em);
+                    }
+                }
+                else {
+                    this->task->SetSucceeded(res);
+                }
+                } catch(...) {
+                    this->task->SetFailed(std::current_exception());
+                }
+            }
+    };
+    TTask* TTask::FromClosure(GCList& ls, TClosure* closure)
+    {
+        auto res =  closure->Call(ls,{});
+        CallStackEntry* ent;
+        if(GetObjectHeap(res,ent))
+        {
+            return FromCallStackEntry(ls,ent);
+        }
+        return FromResult(ls,res);
+    }
+    TTask* TTask::FromCallStackEntry(GCList& ls, CallStackEntry* ent)
+    {
+        TTask* task = TTask::Create(ls);
+
+        //try {
+            GCList ls2(ls.GetGC());
+            GC* gc = ls.GetGC();
+            
+            std::shared_ptr<TTaskCseObj> obj = std::make_shared<TTaskCseObj>(gc,task);
+
+
+            ls2.Add(task);
+            auto res = ent->Pop(ls2);
+            TTask* task2;
+            if(GetObjectHeap(res,task2))
+            {
+                auto em = TExternalMethod::Create(ls2,"",{},[ent,task,obj](GCList& ls, std::vector<TObject> args)->TObject {
+                    
+                    obj->Invoke(obj,ent,args.empty() ? (TObject)Undefined():args[0]);
+
+                    return nullptr;
+                });
+                em->watch.push_back(task);
+                em->watch.push_back(ent);
+               
+                task2->ContinueWith(em);
+            }
+
+        /*} catch(...) {
+            task->SetFailed(std::current_exception());
+        }*/
+
+        return task;
+    }
+}