📌 Nodepp | Bug Fixing - Github Action for cross-platform compilation testing | V1.2.12 📌

Author: EDBCREPO

README.md

@@ -180,6 +180,7 @@ void onMain() {
 - 🔗: [Nodepp for WASM](https://github.com/NodeppOfficial/nodepp-wasm)
 
 ## Projects made with NodePP
+- 🔗: [Computer Vision VR Controllers for phones Demo](https://github.com/PocketVR/Barely_VR_AR_Controller_Test)
 - 🔗: [Draw on your PC using your smartphone](https://github.com/ScreenDraw/PCDraw)
 - 🔗: [Simple multiplayer Game With Raylib](https://medium.com/@EDBCBlog/create-your-own-online-multiplayer-small-fast-and-fun-with-raylib-nodepp-and-websockets-190f5c174094)
 - 🔗: [Cursed Luna - A simple Raylib Game](https://github.com/EDBCREPO/Space-Shocker)
@@ -197,6 +198,7 @@ Check out some articles on [Medium](https://medium.com/@EDBCBlog)
 - 🔗: [SerialPP](https://github.com/NodeppOfficial/nodepp-serial)     -> Serial Port for Nodepp
 - 🔗: [Argon2](https://github.com/NodeppOfficial/nodepp-argon2)       -> Argon2 for Nodepp
 - 🔗: [Torify](https://github.com/NodeppOfficial/nodepp-torify)       -> HTTP|Ws over Tor
+- 🔗: [GPUPP](https://github.com/NodeppOfficial/nodepp-gpu)           -> GPGPU for Nodepp
 - 🔗: [NginxPP](https://github.com/NodeppOfficial/nodepp-nginx)       -> Reverse Proxy
 - 🔗: [InputPP](https://github.com/NodeppOfficial/nodepp-input)       -> Fake Inputs
 - 🔗: [XML](https://github.com/NodeppOfficial/nodepp-xml)             -> XML for Nodepp

include/nodepp/generator.h

@@ -545,7 +545,7 @@ namespace nodepp { namespace generator { namespace ws {
 
     public:
 
-    template<class T> coEmit( T* str, char* bf, const ulong& sx ) { int c=0;
+    template<class T> coEmit( T* str, char* bf, const ulong& sx ) {
     coBegin ; memset( bf, 0, sx ); size=0; data=0; len=0; key=0;
               memset( &frame, 0, sizeof(ws_frame_t) );
 

include/nodepp/nodepp.h

@@ -90,7 +90,7 @@ namespace nodepp { namespace process { array_t<string_t> args;
     /*─······································································─*/
 
     void start( int argc, char** args ){
-        int i=0; onSIGEXIT.once([=](){ process::exit(1); }); do {
+        int i=0; onSIGEXIT.once([=](){ process::exit(0); }); do {
         if(!regex::test(args[i],"^\\?") ) {
             process::args.push(args[i]);
         } else {
@@ -104,7 +104,7 @@ namespace nodepp { namespace process { array_t<string_t> args;
     void stop(){ 
         while(!process::should_close() )
              { process::next(); }
-        process::exit(1);
+        process::exit(0);
     }
 
     /*─······································································─*/

include/nodepp/object.h

@@ -114,10 +114,7 @@ namespace nodepp { class object_t {
     bool has_value()      const { return obj->type<0?false:obj->mem.has_value(); }
     uint type_size()      const { return obj->type<0?false:obj->mem.type_size(); }
 
-    template< class U > U as() const { 
-    try { return obj->mem.as<U>(); } catch( except_t ) {
-          throw except_t( "item does not exists" );
-    } }
+    template< class U > U as() const { return obj->mem.as<U>(); }
 
     /*─······································································─*/
 

include/nodepp/posix/cluster.cpp

@@ -127,7 +127,8 @@ namespace nodepp { class cluster_t : public generator_t {
     void free() const noexcept {
 
         if( is_state( FILE_STATE::REUSE ) && obj.count()>1 ){ resume(); return; }
-        if( is_state( FILE_STATE::KILL  ) ){ return; } close(); kill();
+        if( is_state( FILE_STATE::KILL  ) ){ return; }
+        if(!is_state( FILE_STATE::CLOSE ) ){ kill(); onDrain.emit(); } else { kill(); }
 
     /*
         obj->input.close(); obj->output.close();

include/nodepp/posix/epoll.cpp

@@ -61,7 +61,7 @@ namespace nodepp { class poll_t : public generator_t {
     /*─······································································─*/
 
     template< class T, class... V >
-    void* push( int fd, T cb, const V&... arg ) const noexcept {
+    void* push( int fd, T cb, const V&... args ) const noexcept {
 
         ptr_t<waiter> tsk = new waiter();
         auto clb=type::bind( cb );
@@ -70,7 +70,7 @@ namespace nodepp { class poll_t : public generator_t {
         obj->queue.push({ fd, [=](){
             if( tsk->out==0 ){ return -1; }
             if( tsk->blk==1 ){ return  1; } 
-                tsk->blk =1; int rs=(*clb)( arg... );
+                tsk->blk =1; int rs=(*clb)( args... );
             if( clb.null () ){ return -1; }  
                 tsk->blk =0; return !tsk->out ? -1 : rs;
         } }); 

include/nodepp/posix/file.cpp

@@ -52,9 +52,10 @@ namespace nodepp { class file_t {
         int          feof     =  1;
         ptr_t<char>  buffer;
         string_t     borrow;
-        limit::probe_t limit_probe;
     };  ptr_t<NODE> obj;
 
+    /*─······································································─*/
+
     bool is_std() const noexcept { return obj->fd>0 && obj->fd<3; }
 
     /*─······································································─*/
@@ -176,8 +177,9 @@ namespace nodepp { class file_t {
 
     virtual void free() const noexcept {
 
-        if( is_state(FILE_STATE::REUSE) && obj.count() > 1 ){ resume(); return; }
-        if( is_state(FILE_STATE::KILL ) ){ return; } close(); kill();
+        if( is_state( FILE_STATE::REUSE ) && obj.count() > 1 ){ resume(); return; }
+        if( is_state( FILE_STATE::KILL  ) ){ return; } 
+        if(!is_state( FILE_STATE::CLOSE ) ){ kill(); onDrain.emit(); } else { kill(); }
 
         onUnpipe.clear(); onResume.clear();
         onError .clear(); onStop  .clear();

include/nodepp/posix/kpoll.cpp

@@ -63,7 +63,7 @@ namespace nodepp { class poll_t : public generator_t {
     /*─······································································─*/
 
     template< class T, class... V >
-    void* push( int fd, T cb, const V&... arg ) const noexcept {
+    void* push( int fd, T cb, const V&... args ) const noexcept {
 
         ptr_t<waiter> tsk = new waiter();
         auto clb=type::bind( cb );
@@ -72,7 +72,7 @@ namespace nodepp { class poll_t : public generator_t {
         obj->queue.push({ fd, [=](){
             if( tsk->out==0 ){ return -1; }
             if( tsk->blk==1 ){ return  1; } 
-                tsk->blk =1; int rs=(*clb)( arg... );
+                tsk->blk =1; int rs=(*clb)( args... );
             if( clb.null () ){ return -1; }  
                 tsk->blk =0; return !tsk->out ? -1 : rs;
         } }); 

include/nodepp/posix/limit.cpp

@@ -49,10 +49,3 @@ namespace nodepp { namespace limit { ulong _count_=0;
 }}
 
 /*────────────────────────────────────────────────────────────────────────────*/
-
-namespace nodepp { namespace limit { class probe_t{ public:
-    virtual ~probe_t() noexcept { --_count_; }
-    /*----*/ probe_t() noexcept { ++_count_; }
-};}}
-
-/*────────────────────────────────────────────────────────────────────────────*/

include/nodepp/posix/npoll.cpp

@@ -76,7 +76,7 @@ namespace nodepp { class poll_t : public generator_t {
         obj->queue.push([=](){
             if( tsk->out==0 ){ return -1; }
             if( tsk->blk==1 ){ return  1; } 
-                tsk->blk =1; int rs=(*clb)( arg... );
+                tsk->blk =1; int rs=(*clb)( args... );
             if( clb.null()  ){ return -1; }  
                 tsk->blk =0;   return !tsk->out?-1:rs;
         });