Tell defines a dedicated data type for callback handling. It follows the function declaration syntax with two differences:

Two forms are possible. The second is anonymous.

Callback declarations

callback return_type type_name ([argtype [, argtype […]]]) callback return_type ([argtype [, argtype […]]]) var_name ___________________________________________ return_type the return type of the functions which references can be assigned to this type type_name the name of the type which is declared here argtype the type of the function arguments var_name the name of the variable when anonymous callback declaration is used

Although admittedly a bit verbose, callback declaration syntax ensure that all necessary checks can be done in parse time. Once declared, the callback type can be used exactly as any other Tell type.

Only the names of known functions can be assigned to a callback variables. They have to be prefixed by & as in the examples below.

  int simpleAdd(int a, int b)  {    return (a + b);  }

  int simpleSub(int a, int b)  {    return (a - b);  }

  // define a callback type unifunctype ...
  callback int unifunctype(int,int);

  // ... and a variable unifunc of that type
  unifunctype unifuncA = &simpleAdd;

  printf("Callback of type unifuncA - returns %d\n",unifuncA(2,3));
  unifuncA = &simpleSub;
  printf("Callback of type unifuncA - returns %d\n",unifuncA(2,3));

  // or define directly a variable unifunc of anonymous callback type
  callback int (int,int) unifuncB = &simpleAdd;

  printf("Callback of type unifuncB - returns %d\n",unifuncB(2,3));
  unifuncB = &simpleSub;
  printf("Callback of type unifuncB - returns %d\n",unifuncB(2,3));

  //same for the function argument list:
  //... using a pre-defined callback type
  void funcArguFuncA(int a, int b, unifunctype unifunc)
  {
    int result = unifunc(a,b);
    string buffer = sprintf ("%d fparam %d is %d", a, b, result);
    printf ("[%s] \n",buffer);
  }

  // ... or anonymous callback type
  void funcArguFuncB(int a, int b, callback int (int,int) unifunc)
  {
    int result = unifunc(a,b);
    string buffer = sprintf ("%d fparam %d is %d", a, b, result);
    printf ("[%s] \n",buffer);
  }

  funcArguFuncB(2,3,&simpleAdd);
  funcArguFuncB(2,3,&simpleSub);
  funcArguFuncA(2,3,&simpleAdd);
  funcArguFuncA(2,3,&simpleSub);

Here is a quick example of a function calling itself

int factoriel(real stop)
{
   if (stop > 0)
   {
      int inter = factoriel(stop - 1);
      return (stop * inter);
   };
   return 1;
}

top

top

   point list arc(point center, int radius, int start, int stop, int numsteps)
   {
      real step = abs(stop -start) / numsteps;
      real current = start;
      point list the_arc;
      while (current <= stop)
      {
         point cur_point;
         cur_point.x = center.x + radius * cos(current);
         cur_point.y = center.y + radius * sin(current);
         current = current + step;
         the_arc[:+] = cur_point;
      }
      return the_arc;
   }

top

top

top

Returns the list length. Empty lists are valid and their length will be 0

	int length( llst )
	<any> list llst input list

   int list b;
   echo(length(b));

top

Prints the value of a TELL variable. This function is rather temporary. It takes any type of argument and prints its value in the log window. It could be useful for some very basic debugging of the TELL script.

	void echo( variable )
	<any_type> variable A variable of any valid TELL type.

   echo("Welcome");
   point list triangle{{0,0},{1,2},{3,4}};
   echo (triangle);

top

Write formatted data to the Tell log. This function mimics the syntax of the corresponding C function and works in a similar way. It implements the functionality of the C format tags including the flags, width, precision and length parameters.

	void printf( format [,param [,param [,…]]] )
	string format The text to be written on the log console. It can optionally contain format tags. <legal_type> param Zero or more comma separated variables. Their number and types shall strictly correspond to the tags in the format string. Legal types are int, real and string. The function won’t accept any of the Tell specific or user defined types.

The differences with the standard C printf implementation are listed below:

The definition of the format tags is widely available on external C/C++ reference sources - for example here

top

Write formatted data to a string. Exactly like printf, but instead of the log console it writes all the output in the returned string.

	string sprintf( format [,param [,param [,…]]] )
	string format The text to be written on the log console. It can optionally contain format tags. <legal_type> param Zero or more comma separated variables. Their number and types shall strictly correspond to the tags in the formatting string. Legal types are int, real and string. The function won’t accept any of the Tell specific or user defined types.

The differences with the standard C implementation of sprintf are listed below:

The definition of the format tags is widely available on external C/C++ reference sources - for example here

top

Executes external OS command. Current implementation is rather experimental. The function itself doesn’t return a result or status. The standard input and output is redirected to the Toped console and is highly dependent on the platform.

	void exec(argument)
	string argument external command to be executed

The primary purpose of this function is to launch external scripts.

   exec("ls");  //On Linux
   exec("dir"); //On Windows

top

Exits the current session. Intended to be used from TELL scripts. If database contains unsaved objects the function will still ask to save it before exiting.

	void exit()
	-

top