What is ECL?

Syntax

(func1 (arg1 arg2))
(func2 ())

This is a comment in ECL
(print ("hello world"))
The above line printed hello world to stdout.
(print ("hello again"))

(
  print (
    + (2 3)
    * (5 6)
  )
)

Any whitespace separates arguments. For example,

(print (hello there))

(print ("hello there"))

(print (hello c 17 4.56))

Addition, and multiplication return the sum or product of their arguments:

(print (+ (2 3 4)))
(print (+ (2)))
(print (* (2 3 4)))
(print (* (3)))

9
2
24
3

Subtraction, division, and modulus work as follows:

(print (- (2 3 4)))
(print (- (2)))
(print (/ (2 3 4)))
(print (/ (3)))
(print (% (9 5 3)))

-5
 2
 0.166667
 3
 1

(set (var 4))
(set (words "hello world"))
(set (func print))
($func ($var $words))
(set (a +(2 3 4)))
(print ($a))

4 hello world
7

(set (a 4))
(print ($a))
(set (a 8))
(print ($a))

4
8

(set (a 4))
(print ($a))
(unset (a))

• as an interactive command interpreter
• to process commands from a file
• to process individual commands giving control back to the main program

All programs which use ECL must declare #include "ecl.h" and must call ecl_init() before calling any other ECL functions. From that point, to enter the interactive command interpreter, call ecl_cmdint(). To execute commands in a file, call ecl_cmds_from_file().

1. All functions must return a value.
2. All functions must have a defined behaviour for input of any type.
3. All functions must be in the function table in table.c

Parameter to functions in ECL are of type ecl_node_ptr which is defined in ecl_types.h as follows:

typedef enum {ecl_float_t,ecl_int_t,ecl_char_t,ecl_string_t,ecl_null_t} ecl_type_t;

typedef struct {
  union {
    double f;
    long i;
    char c;
    char *s;
  } u;
  ecl_type_t type;
} var, *var_ptr;

typedef struct ecl_node {
  char *key;
  var value;
  struct ecl_node *parent;
  struct ecl_node *children;
  struct ecl_node *next;
} ecl_node, *ecl_node_ptr;

ecl_boolean print(ecl_node_ptr in){
  /* simply print out our arguments in tab-delimited form to stdout */

  ecl_node_ptr parent; /* we need this to set the return value */
  if (!in){ /* if in is NULL then we have no arguments */
    ecl_set_error("print - no arguments"); /* set the error condition */
    return true; /* return value of true indicates there was an error */
  }
  parent=in->parent; /* keep our parent */
  while (in){ /* iterate over all arguments */
    switch (in->value.type){ /* what type is the current arg */
    case ecl_string_t: /* is it a string? */
      printf("%s\t",in->value.u.s); /* print the string part of the union */
      break;
    case ecl_char_t: /* is it a char? */
      printf("%c\t",in->value.u.c); /* print the char part of the union */
      break;
    case ecl_int_t: /* is it an int? */
      printf("%ld\t",in->value.u.i); /* print the int part of the union */
      break;
    case ecl_float_t: /* is it a float? */
      printf("%f\t",in->value.u.f); /* print the float part of the union */
      break;
    case ecl_null_t: /* if it is null, don't print anything */
      break;
    }
    in=get_next_arg(in); /* get the next arg */
  }
  printf ("\n"); /* since we are printing tab-delimited, end the line */
  /* we don't return anything, so set our parent's value to null */
  parent->value.type=ecl_null_t;
  if (parent->value.type==ecl_string_t) /* does out parent have a string as a value? */
    free(parent->value.u.s); /* free the string to avoid leaks */
  return false; /* there were no errors */
}

ecl_boolean add(ecl_node_ptr in){
  ecl_node_ptr parent;
  double sum=0; /* to keep the result */

  if (!in){
    ecl_set_error("add - no arguments"); /* were there any arguments? */
    return true; /* return error condition */
  }
  parent=in->parent; /* keep our parent for the return value */
  while (in){ /* iterate over all the arguments */
    switch(in->value.type){ /* what type is the current arg? */
    case ecl_string_t:
      /* don't know how to do string addition yet - skip it */
      break;
    case ecl_char_t:
      /* don't know how to do char addition either - skip it */
      break;
    case ecl_int_t:
      /* this we know how to do */
      sum+=in->value.u.i;
      break;
    case ecl_float_t:
      /* this too */
      sum+=in->value.u.f;
      break;
    case ecl_null_t:
      break;
    }
    in=get_next_arg(in); /* get the next argument */
  }
  /* free the parent's string if there was one */
  if (parent->value.type==ecl_string_t)
    free(parent->value.u.s);
  /* now figure out the type of our return value */
  if ((sum-(int)sum)==0){ /* we are an int */
    parent->value.type=ecl_int_t; /* set return type to int */
    parent->value.u.i=sum; /* set the sum */
  }
  else{
    parent->value.type=ecl_float_t; /* set return type to float */
    parent->value.u.f=sum; /* set the sum */
  }
  return false; /* there were no errors */
}

• conditional evaluation
• looping contructs
• vector and matrix types