/*
	Est-ce qu"on peut générer un class contenant des références à des variables
	On cherche à savoir s'il serait facile de modifier tlcc, le convertisser tlmp -> c++
	pour qu'il supporte la syntaxe suivante:

	<mod>
	void f(vector<string> &v)
	{
		glocal &v;
		<call loadfile>("fichier",true);
		<f oneline>
			glocal.v.push_back(line);
			return 0;
		</f>
		</call>
	}
	</mod>

	Présentement, on ne peut faire que ceci
	<mod>
	void f(vector<string> &v)
	{
		glocal vector<string> *v = &v;
		...
			glocal.v->push_back(line);

	La syntaxe force une répétition et l'usage de la syntaxe pointeur. De plus, dans le cas des map
	cela rend cela encore agaçant ;
	<mod>
	void f(map<string,int> &v)
	{
		glocal map<string,int> *v = &v;
		...
			(*glocal.v)[line]++;

	La fonction test_pour_tlmp démontre que ça se fait et que c'est même binaire compatible avec le
	code déjà compîlé.

	Ne semble pas plus lent.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlmplib.h>
#include <string>
#include <vector>
#include "refer.h"
#include "getnow.h"

using namespace std;

void f (int &a, vector<int> &v)
{
	using __type_a = decltype(a);
	using __type_v = decltype(v);
	struct gl{
		__type_a a;
		__type_v v;
		int e;
		gl(__type_a _a, __type_v _v) :a(_a),v(_v){}
	} g(a,v);
	g.e=10;
	printf ("a=%d\n",g.a);
	for (auto val:g.v) printf ("g.pv[]=%d\n",val);
	g.a++;
	for (auto &val:g.v) val++;
	g.v.push_back(40);
};

struct tlmpcomp{
	virtual void print(int a){
		printf ("base tlmpcomp a=%d\n",a);
	}
};


void test_pour_tlmp(int &a, vector<int> &v)
{
	using __type_a = decltype(a);
	using __type_v = decltype(v);
	struct gl{
		__type_a &a;
		__type_v &v;
		int e;
		gl(__type_a _a, __type_v _v) :a(_a),v(_v){}
	} g(a,v);

	struct _X: public _F_loadfile__v1{
		gl &g;
		_X(gl &_g) : g(_g){}
		_F_loadfile__v1_oneline( ){
			g.a++;
			g.v.push_back(noline);
			printf ("v[]=");
			for (auto val:g.v) printf (" %d",val);
			printf ("\n");
			printf ("g.a=%d line=%s\n",g.a,line);
			return 0;
		}
	}_x(g);
	loadfile__v1(_x,"/tmp/toto.html",true);
}


<mod>
int main (int argc, char *argv[])
{
	glocal int ret = -1;
	glocal unsigned nbrep=1;
	glocal bool testperf = false;
	glocal bool test1 = false;
	glocal.ret = <call tlmpprogram>(argc,argv);
	<f init>
		setproginfo ("","0.0","...");
		setarg ('n',"nbrep","Nombre de repetition",glocal.nbrep,false);
		setarg (' ',"test1","Premier test pour montrer que ça fonctionne",glocal.test1,false);
		setarg (' ',"testperf","Compare la performance",glocal.testperf,false);
	</f>
	<f main_noarg>
		int ret = -1;
		if (glocal.test1){
			int v = 22;
			v++;
			vector<int>vec{1,2,3,4};
			for (auto val:vec) printf ("v[]=%d\n",val);
			f(v,vec);
			printf ("v=%d\n",v);
			for (auto val:vec) printf ("v[]=%d\n",val);
			test_pour_tlmp(v,vec);
			printf ("v=%d\n",v);
			for (auto val:vec) printf ("v[]=%d\n",val);
		}else if (glocal.testperf){
			// Il a fallut déplacer le code dans un autre fichier parce que le compilateur optimisait tout.
			// On multipliait nbrep par 1,000,000 et ça changeait pas le temps d'exécution (0).
			// et le résultat était bon.
			unsigned long rep = (unsigned long)glocal.nbrep*1;
			printf ("nbrep=%u rep=%lu\n",glocal.nbrep,rep);
			{
				long long start = getnow();
				unsigned long count = <call loop>(1,rep);
				<f exec>
					unsigned long ret = <call loop>(val,20);
					<f exec>
						return val*2;
					</f>
					</call>
					return ret;
				</f>
				</call>
				long long end = getnow();
				showtime("standard",start,end);
				printf ("count=%lu sizeof %lu\n",count,sizeof(count));
			}
			{
				long long start = getnow();
				class _F_loop_test: public _F_loop{
					_F_loop_exec( ){
						class _F_loop_stest: public _F_loop{
							_F_loop_exec( ){
								return val*3;
							}
						}c;
						return loop(c,val,20);
					}
				}c;
				unsigned long count = loop(c,1,rep);
				long long end = getnow();
				showtime("inline",start,end);
				printf ("count=%lu\n",count);
			}
		}else{
			usage();
		}
		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>