[Development] Fornux C++ Superset

[Phil Bouchard]

Greetings,

Because Qt is very powerful, I would like to clarify the importance of 
the following problems despite my previous informal attempts:
- The recent Qt 5.10.1 still randomly crashes for apps written on the 
iPhone and for the Android as well.
- QML is an interpreted language thus it can be reverse engineered and 
plagiarized quite easily.

As you know 1 crash makes your application worthless. Those are facts, 
whether today's mainstream developers like it or not.

I have a solution that solves those problems and it's called: "Fornux 
C++ Superset":

- Fornux C++ Superset harnesses the power of Clang.
- It now supports, as you have guessed, C++98 syntax.
- It's deterministic so it will not slow down your application randomly 
like with Java.
- You can see attached examples memory leaks in C & C++ with cyclic 
references which are correctly handled and the memory usage never increases.

Like I mentioned previously, I am working hard on a free version I will 
be able to share in a month or two.


Regards,
Phil Bouchard
www.fornux.com
/**

    Fornux C++ Superset -- Example.

    Outputs:

    Speed: 16043.546433 loops / s; Memory usage: 4552 kilobytes

 */


#include <stdlib.h>
#include <unistd.h>
#include <sys/resource.h>

#include <chrono>
#include <iostream>
#include <iomanip>


using namespace std;
using namespace std::chrono;


struct A
{
    int x;

    int i;
    int j;
};

struct B : virtual A
{
    int k;
    int l;
};

struct C : virtual A
{
    int m;
    int n;
};

struct D : B
{
    int o;
    int p;
};

struct E : C
{
    int o;
    int p;
};

struct list_node : D, E
{
    int q;
    int r;

    list_node * p;
};


int main()
{
    milliseconds before, after;
 
    before = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
    
    for (int i = 0; ; ++ i)
    {
        // cycle
        struct list_node * p = new list_node;
        p->p = new list_node;
        p->p->p = new list_node;
        p->p->p->p = p;
        
        // stats
        after = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
        struct rusage r_usage;
        getrusage(RUSAGE_SELF, & r_usage);
        cout << "\rSpeed: " << setprecision(11) << i * 1000.0 / (after - before).count() << " loops / s; Memory usage: " << r_usage.ru_maxrss << " kilobytes" << flush;
        usleep(1);
    }
 
    return 0;
}
/**

    Fornux C++ Superset -- Example.

    Outputs:
    
    Speed: 16563.387712 loops / s; Memory usage: 4544 kilobytes
    
 */


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>


double time_diff(struct timeval x , struct timeval y);

struct list_node
{
    struct list_node * p;
};


int main()
{
    struct timeval before, after;
 
    gettimeofday(& before, (struct timezone *) NULL); 
    
    for (int i = 0; ; ++ i)
    {
        // cycle
        struct list_node * p = malloc(sizeof(struct list_node));
        p->p = malloc(sizeof(struct list_node));
        p->p->p = malloc(sizeof(struct list_node));
        p->p->p->p = p;
        
        // stats
        gettimeofday(& after, (struct timezone *) NULL);
        struct rusage r_usage;
        getrusage(RUSAGE_SELF, & r_usage);
        printf("\rSpeed: %f loops / s; Memory usage: %ld kilobytes", i * 1000000.0 / time_diff(before , after), r_usage.ru_maxrss);
        fflush(stdout);
        usleep(1);
    }
 
    return 0;
}
 
double time_diff(struct timeval x , struct timeval y)
{
    double x_ms , y_ms , diff;
     
    x_ms = (double)x.tv_sec*1000000 + (double)x.tv_usec;
    y_ms = (double)y.tv_sec*1000000 + (double)y.tv_usec;
     
    diff = (double)y_ms - (double)x_ms;
     
    return diff;
}
_______________________________________________
Development mailing list
Development@qt-project.org
http://lists.qt-project.org/mailman/listinfo/development