On Mon, 10 Oct 2016, Wouter van Ooijen wrote:

> In your idea, as a user, can I be *sure* that a certain (complicated)
> part is run by the compiler at compilation?
>
> In C++ 0x14 you can
>
> - declare any function as constexper, which means that the compiler must
> check that it can evaluate that function at compile time (provided that
> it knows the arguments at compile time). Such a function is still usable
> at run time too.
>
> - declare any const value as constexpr, which means that the compiler
> must evaluate it at compile time.
>
> There isn't much special about a constexpr function that isn't obvious
> (like: it can't access globals, can't do memory allocation, etc.).

Hi Wouter,

The short answer is yes - if you declare a constant and use a function to=20
initalise it that does not depend on external unknowns.

The longer answer is "it is not intended to be restricted that way". When=20
I explained how functions could be executed at compile time this was an=20
attempt to quickly focus the reader on an obvious benefit. The reallity=20
however is that compile time execution goes way beyond what I described.=20
It opens up a huge number of possibilites for deep analysis and=20
optimisation which I have not described. It is not just about executing=20
functions as a unit but about executing as much of the code as possible=20
without the function call acting as a barrier.

What I would like to see users doing is writing code that describes the=20
process they need to achive and let the compiler worry about the=20
optimisation.

This is an example of what I would like the user to be able to do:

Standard(ish) C:

header file: myblob.h

 	struct MYBLOB
 		{
 			int	X[MYBLOB_X_LEN];
 			char	Y[MYBLOB_Y_LEN];
 			float	Z[MYBLOB_Z_LEN];
 		};

 	MYBLOB	blob;

 	void init_blob(void)
 	{
 		for (int j=3D0; j<MYBLOB_X_LEN; j++)
 		{
 			blob.X[j] =3D 0;
 		}

 		for (int j=3D0; j<MYBLOB_Y_LEN; j++)
 		{
 			blob.Y[j] =3D 0;
 		}

 		for (int j=3D0; j<MYBLOB_Z_LEN; j++)
 		{
 			blob.Z[j] =3D 0;
 		}
 	}

source file: myblob.c

 	#define MYBLOB_X_LEN 3
 	#define MYBLOB_Y_LEN 20
 	#define MYBLOB_Z_LEN 5

 	#include "myblob.h"

 	main()
 	{
 		init_blob();
 		...
 	}


They should be able to write something like:

My new language(ish):

header file: myblob.h

 	const	int	MYBLOB_X_LEN =3D ???
 	const	int	MYBLOB_Y_LEN =3D ???
 	const	int	MYBLOB_Z_LEN =3D ???

 	struct MYBLOB
 		{
 			int	X[MYBLOB_X_LEN];
 			char	Y[MYBLOB_Y_LEN];
 			float	Z[MYBLOB_Z_LEN];
 		};

 	MYBLOB	blob;

 	void init_myblob(int x, int y, int z)
 	{
 		MYBLOB_X_LEN =3D x;
 		MYBLOB_Y_LEN =3D y;
 		MYBLOB_Z_LEN =3D z;

 		for (int j=3D0; j<MYBLOB_X_LEN; j++)
 		{
 			blob.X[j] =3D 0;
 		}

 		for (int j=3D0; j<MYBLOB_Y_LEN; j++)
 		{
 			blob.Y[j] =3D 0;
 		}

 		for (int j=3D0; j<MYBLOB_Z_LEN; j++)
 		{
 			blob.Z[j] =3D 0;
 		}
 	}


source file: myblob.c

 	#include "myblob.h"

 	main()
 	{
 		init_myblob(3, 20, 5);
 		...
 	}

Note how the user no longer needs to worry about the C manifest constants=20
MYBLOB_X_LEN, MYBLOB_Y_LEN and MYBLOB_Z_LEN.

In the above example, part of init_myblob was executed at compile time=20
(the initialisation of the constants) and part was converted to runtime=20
executable code (the initialisation of the arrays).

One of my goals is to simplify things for the user without adding a=20
burden to the generated executable.

They should not have to worry about how libraries are compiled or what glob=
al=20
constants get defined ***AND*** the result should be at least as optimised=
=20
as the hand crafted C stuff.

Something else I would like a user to be able to do is something like:

 	void func(int x)
 	{
 	static	int	flg =3D false;

 		if (!flg)
 		{
 			flg =3D true;

 			perform_init_sequence
 		}

 		perform_normal_function
 	}

In the above I would like to see the compiler executing the=20
'perform_init_sequence' at compile time and the 'perform_normal_function'
in the target.

Regards
Sergio Masci
--=20
http://www.piclist.com/techref/piclist PIC/SX FAQ & list archive
View/change your membership options at
http://mailman.mit.edu/mailman/listinfo/piclist
.