Not all functions can be described by calling other functions of the same language. For this reason and for performance reasons several functions are defined using a mechanism called action. For example: It is easy to define the 'while' statement by using recursion. But this would hurt performance and it would also use a huge amount of memory for the runtime stack. In practise an implementation of the 'while' statement can use a conditional jump instead of a subroutine call. Since Seed7 has no 'goto' statement, this is not an option. Instead the primitive action PRC_WHILE can be used. The 'while' statement is defined in the basic Seed7 library 'seed7_05.s7i' with:

    const proc: while (in func boolean param) do
        (in proc param) end while is action "PRC_WHILE";

This declaration shows the types and the position of the parameters of a 'while' statement. Such an action declaration contains enough information to use the defined construct. The semantic of all primitive actions is hard coded in the interpreter and in the compiler. The parameters of the hard coded actions and the corresponding definitions in Seed7 must match. If you are interested in the Seed7 definitions of primitive actions just look into the file 'seed7_05.s7i'.

Currently there are several hundred primitive actions predefined in the interpreter. They all have names in upper case characters which have the form:

    TYPE_ACTION

Which means that for example all 'integer' actions start with INT_ and all assignment actions end with _CPY . The following list shows actions which are used with more than one type:

    _ABS      Absolute value
    _ADD      Addition
    _CAT      Concatenation
    _CMP      Compare
    _CPY      Copy (Assignment)
    _CREATE   Initialize (Construct)
    _DESTR    Destroy (Destruct)
    _DECR     Decrement
    _DIV      Division
    _EQ       Equal
    _GE       Greater equal
    _GETC     Get one character from a file
    _GETS     Get string with maximum length from a file
    _GT       Greater than
    _HASHCODE Compute a hashCode
    _HEAD     Head of ref_list, array, string
    _ICONV    Conversion of integer to another type
    _IDX      Index (Element) of ref_list, array, string
    _INCR     Increment
    _LE       Less equal
    _LNG      Length
    _LOG2     Base 2 logarithm
    _LOWER    Convert to lower case
    _LSHIFT   Shift left
    _LT       Less than
    _MDIV     Modulo division (Integer division truncated towards negative infinity)
    _MINUS    Change sign
    _MOD      Modulo (Reminder of _MDIV integer division)
    _MULT     Multiply
    _NE       Not equal
    _ODD      Odd number
    _ORD      Ordinal number
    _PARSE    Conversion of string to another type
    _PLUS     Positive sign (noop)
    _POW      Power
    _PRED     Predecessor
    _RAND     Random value
    _RANGE    Range of ref_list, array, string
    _REM      Remainder (Reminder of _DIV integer division)
    _RSHIFT   Arithmetic shift right
    _SBTR     Subtract
    _SCAN     Convert from string to another type
    _SEEK     Set actual file position of a file
    _SQRT     Square root
    _STR      Convert to string
    _SUCC     Successor
    _TAIL     Tail of ref_list, array, string
    _TELL     Return the actual file position
    _UPPER    Convert to upper case
    _VALUE    Dereference a reference
    _WRITE    Write string to file

Primitive actions are defined for many types. The functions which implement the primitive actions are grouped together in *lib.c files. The following list contains the action prefix, the file containing the functions and a description:

    ACT_  actlib.c  ACTION operations
    ARR_  arrlib.c  array operations
    BIG_  biglib.c  bigInteger operations
    BLN_  blnlib.c  boolean operations
    BST_  bstlib.c  Operations for byte strings
    CHR_  chrlib.c  char operations
    CMD_  cmdlib.c  Various directory, file and other commands
    DCL_  dcllib.c  Declaration operations
    DRW_  drwlib.c  Drawing operations
    ENU_  enulib.c  Enumeration operations
    FIL_  fillib.c  PRIMITIVE_FILE operations
    FLT_  fltlib.c  float operations
    HSH_  hshlib.c  hash operations
    INT_  intlib.c  integer operations
    ITF_  itflib.c  Operations for interface types
    KBD_  kbdlib.c  Keyboard operations
    LST_  lstlib.c  List operations
    PRC_  prclib.c  proc operations and statements
    PRG_  prglib.c  Program operations
    REF_  reflib.c  reference operations
    RFL_  rfllib.c  ref_list operations
    SCR_  scrlib.c  Screen operations
    SCT_  sctlib.c  struct operations
    SET_  setlib.c  set operations
    SOC_  soclib.c  PRIMITIVE_SOCKET operations
    STR_  strlib.c  string operations
    TIM_  timlib.c  time and duration operations
    TYP_  typlib.c  type operations
    UT8_  ut8lib.c  utf8_file operations

The C functions which implement primitive actions have lowercase names. E.g.: The action 'PRC_WHILE' is implemented with the C function 'prc_while()' in the file 'prclib.c'. The parameter list for all C action functions is identical. Every *lib.c file has a corresponding *lib.h file which contains the prototypes for the action functions.

The primitive action which describes the addition of two integers is 'INT_ADD'. The Seed7 interface to the action 'INT_ADD' is defined in the file 'seed7_05.s7i' with:

    const func integer: (in integer param) + (in integer param) is action "INT_ADD";

To execute an action a corresponding C function must be present in the hi interpreter. The function for the action 'INT_ADD' is 'int_add()'. The function 'int_add()' is defined in the file 'intlib.c' with:

    #ifdef ANSI_C

    objecttype int_add (listtype arguments)
    #else

    objecttype int_add (arguments)
    listtype arguments;
    #endif

      { /* int_add */
        isit_int(arg_1(arguments));
        isit_int(arg_3(arguments));
        return(bld_int_temp(
            take_int(arg_1(arguments)) +
            take_int(arg_3(arguments))));
      } /* int_add */

The action functions use ANSI C prototypes and K&R function headers. The function 'int_add()' adds the first and the third argument (the second argument contains the + symbol. The file 'memory.h' contains several macros and functions which help to handle the arguments (parameter list) of a C primitive action function.

• The macros 'arg_1', 'arg_2', 'arg_3', etc. can be used to get an individual argument (E.g.: 'arg_3(arguments)' ).
• The macros 'isit_int', 'isit_stri', 'isit_file', etc. can be used to check for the correct category of an argument (E.g.: 'isit_int(arg_1(arguments))' ).
• The macros 'take_char', 'take_float', 'take_bigint', etc. can be used to get the corresponding value of an argument (E.g.: 'take_int(arg_1(arguments))' ).
• The functions 'bld_int_temp', 'bld_array_temp', 'bld_win_temp', etc. can be used to create the (objecttype) result of a primitive action (E.g.: 'return(bld_int_temp(0))' ).

The file 'intlib.h' contains the prototype for the 'int_add()' function:

    objecttype int_add (listtype);

and also a definition for the K&R C language:

    objecttype int_add ();

Additionally every primitive action is registered in the file 'primitive.c'. The line which incorporates 'INT_ADD' is:

    { "INT_ADD",             int_add,             },

The entries of the primitive action in the file 'primitive.c' are sorted alphabetically. With this definitions the hi interpreter understands a primitive action.

To allow a primitive function in a compiled Seed7 program the Seed7 compiler (comp.sd7) needs to know the action also. The compiler function which creates code for the 'INT_ADD' action is:

    const proc: process_int_add (in ref_list: params, inout expr_type: c_expr) is func

      begin
        c_expr.expr &:= "(";
        process_expr(params[1], c_expr);
        c_expr.expr &:= ") + (";
        process_expr(params[3], c_expr);
        c_expr.expr &:= ")";
      end func;

This function is called from the function 'process_action' with the line:

    elsif action_name = "INT_ADD" then
      process_int_add(params, c_expr);

Some primitive actions are more complicated and inline code would not be the best solution for it. In this case an additional helper function is used. The action 'INT_STR' is such an action. The definition of the function 'int_str()' in the file 'intlib.c' is:

    #ifdef ANSI_C

    objecttype int_str (listtype arguments)
    #else

    objecttype int_str (arguments)
    listtype arguments;
    #endif

      { /* int_str */
        isit_int(arg_1(arguments));
        return(bld_stri_temp(intStr(
            take_int(arg_1(arguments)))));
      } /* int_str */

The main work for the primitive action 'INT_STR' is done in the helper function 'intStr()'. The helper function 'intStr()' can be found in the file 'int_rtl.c':

    #ifdef ANSI_C

    stritype intStr (inttype number)
    #else

    stritype intStr (number)
    inttype number;
    #endif

      {
        uinttype unsigned_number;
        booltype sign;
        strelemtype buffer_1[50];
        strelemtype *buffer;
        memsizetype len;
        stritype result;

      /* intStr */
        if ((sign = (number < 0))) {
          unsigned_number = -number;
        } else {
          unsigned_number = number;
        } /* if */
        buffer = &buffer_1[50];
        do {
          *(--buffer) = (strelemtype) (unsigned_number % 10 + '0');
        } while ((unsigned_number /= 10) != 0);
        if (sign) {
          *(--buffer) = (strelemtype) '-';
        } /* if */
        len = &buffer_1[50] - buffer;
        if (!ALLOC_STRI(result, len)) {
          raise_error(MEMORY_ERROR);
          return(NULL);
        } else {
          result->size = len;
          memcpy(result->mem, buffer, (SIZE_TYPE) (len * sizeof(strelemtype)));
          return(result);
        } /* if */
      } /* intStr */

The file 'int_rtl.h' contains a prototype definition for the 'intStr()' helper function:

    stritype intStr (inttype number);

and also a definition for the K&R C language:

    stritype intStr ();

The helper functions are also used in the code generated by the Seed7 compiler:

    const proc: process_int_str (in ref_list: params, inout expr_type: c_expr) is func

      begin
        prepare_stri_result(c_expr);
        c_expr.result_expr &:= "intStr(";
        getStdParamToResultExpr(params[1], c_expr);
        c_expr.result_expr &:= ")";
      end func;

All the *lib.c files containing primitive actions and various other files with their functions are grouped together in the 's7_comp.a' library (Licensed under GPL). Furthermore the C primitive action functions (E.g.: int_parse) of the *lib.c files may use corresponding functions (E.g.: intParse) which can be found in *_rtl.c files (E.g.: 'int_rtl.c'). The *_rtl.c files are grouped together in the 'seed7_05.a' library (Licensed under LGPL). When a Seed7 program is compiled with the Seed7 compiler (comp.sd7) inline code is generated for many primitive actions. To implement the remaining primitive actions the functions of the 'seed7_05.a' library are used.