Subversion Repositories iicmb

--==============================================================================

--                                                                             |

--    Project: IIC Multiple Bus Controller (IICMB)                             |

--                                                                             |

--    Module:  Test package.                                                   |

--    Version:                                                                 |

--             1.0,   April 29, 2016                                           |

--                                                                             |

--    Author:  Sergey Shuvalkin, (sshuv2@opencores.org)                        |

--                                                                             |

--==============================================================================

--==============================================================================

-- Copyright (c) 2016, Sergey Shuvalkin                                        |

-- All rights reserved.                                                        |

--                                                                             |

-- Redistribution and use in source and binary forms, with or without          |

-- modification, are permitted provided that the following conditions are met: |

--                                                                             |

-- 1. Redistributions of source code must retain the above copyright notice,   |

--    this list of conditions and the following disclaimer.                    |

-- 2. Redistributions in binary form must reproduce the above copyright        |

--    notice, this list of conditions and the following disclaimer in the      |

--    documentation and/or other materials provided with the distribution.     |

--                                                                             |

-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |

-- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE   |

-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE  |

-- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |

-- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR         |

-- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF        |

-- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS    |

-- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN     |

-- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)     |

-- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE  |

-- POSSIBILITY OF SUCH DAMAGE.                                                 |

--==============================================================================

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

--==============================================================================

package test is

  type integer_array     is array (natural range <>) of integer;

  type integer_array_ptr is access integer_array;

  type string_ptr        is access string;

  type char_file         is file of character;

  ------------------------------------------------------------------------------

  -- The file type declaration above implicitly defines the following operations:

  -- procedure file_open (                               file f : char_file; name : in string; open_kind : in file_open_kind := read_mode);

  -- procedure file_open (status : out file_open_status; file f : char_file; name : in string; open_kind : in file_open_kind := read_mode);

  -- procedure file_close(file f : char_file);

  -- procedure read (file f : char_file; value : out character);

  -- procedure write(file f : char_file; value : in  character);

  -- function  endfile(file f : char_file) return boolean;

  ------------------------------------------------------------------------------

  file stdin  : char_file open read_mode  is "STD_INPUT";

  file stdout : char_file open write_mode is "STD_OUTPUT";

  ------------------------------------------------------------------------------

  -- Printing to a file and stdout:

  constant newline : string := "" & lf;

  procedure fprint_string(file f : char_file; value : in string);

  procedure print_string(value : in string);

  --function to_string(value : in integer; width : in positive := 1) return string;

  --function to_string(value : in std_logic_vector) return string;

  ------------------------------------------------------------------------------

  -- Function for converting integer to string:

  function to_string(value  : in integer;

                     format : in string  := "d";

                     width  : in natural := 0;

                     prec   : in natural := 0) return string;

  function to_string(value  : in std_logic;

                     format : in string  := "b";

                     width  : in natural := 0;

                     prec   : in natural := 0) return string;

  function to_string(value  : in std_logic_vector;

                     format : in string  := "x";

                     width  : in natural := 0;

                     prec   : in natural := 0) return string;

  --

  -- format string: [FLAGS][WIDTH][.PREC]TYPE

  --

  --     * FLAGS

  --        an optional sequence of characters which control output

  --        justification, numeric signs, trailing zeroes, and octal and hex

  --        prefixes.  The flag characters are minus (`-'), plus (`+'), space

  --        ( ), zero (`0'), and sharp (`#').  They can appear in any

  --        combination.

  --

  --       `-'   The result of the conversion is left justified, and the right

  --             is padded with blanks.  If you do not use this flag, the

  --             result is right justified, and padded on the left.

  --

  --       `+'   The result of a signed conversion (as determined by TYPE)

  --             will always begin with a plus or minus sign.  (If you do not

  --             use this flag, positive values do not begin with a plus sign.)

  --

  --       `" " (space)'

  --             If the first character of a signed conversion specification

  --             is not a sign, or if a signed conversion results in no

  --             characters, the result will begin with a space.  If the space

  --             ( ) flag and the plus (`+') flag both appear, the space flag

  --             is ignored.

  --

  --       `0'   Leading zeroes are used to pad the field width (following any

  --             indication of sign or base); no spaces are used for padding.

  --             If the zero (`0') and minus (`-') flags both appear, the zero

  --             (`0') flag will be ignored.  If a precision PREC is specified,

  --             the zero (`0') flag is ignored.  Note that `0' is interpreted

  --             as a flag, not as the beginning of a field width.

  --   

  --       `#'   The result is to be converted to an alternative form,

  --             depending on the conversion type character:

  --

  --            `b'   result will have a `b' prefix.

  --

  --            `o'   increases precision to force the first digit of the

  --                  result to be a zero.

  --

  --            `x'   result will have a `0x' prefix.

  --

  --            `X'   result will have a `0X' prefix.

  --

  --            `all others'

  --                  ignored.

  --

  --     * WIDTH

  --        WIDTH is an optional minimum field width.  You can either specify

  --        it directly as a decimal integer, or indirectly by using instead

  --        an asterisk (`*'), in which case the 'width' argument is used as

  --        the field width.

  --

  --     * PREC

  --        an optional field; if present, it is introduced with "." (a

  --        period).  This field gives the minimum number of digits of an

  --        integer to print.  You can specify the precision either directly as

  --        a decimal integer or indirectly by using an asterisk (`*'), in which

  --        case a 'prec' argument is used as the precision.  If only a period

  --        is specified the precision is zero.

  --

  --     * TYPE

  --        TYPE field specifies what kind of conversion to_string() performs.

  --        Here is a table of these:

  --

  --       `b'   prints a unsigned binary integer;

  --

  --       `d'   prints a signed decimal integer; (same as `i')

  --

  --       `i'   prints a signed decimal integer; (same as `d')

  --

  --       `o'   prints an unsigned octal integer;

  --

  --       `u'   prints an unsigned decimal integer;

  --

  --       `x'   prints an unsigned hexadecimal integer (using `abcdef' as

  --             digits beyond `9');

  --

  --       `X'   prints an unsigned hexadecimal integer (using `ABCDEF' as

  --             digits beyond `9');

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  -- format: [FLAGS][WIDTH][.PREC][SIZE][TYPE]

  --

  --     * FLAGS

  --

  --        an optional sequence of characters which control output

  --        justification, numeric signs, decimal points, trailing zeroes, and

  --        octal and hex prefixes.  The flag characters are minus (`-'), plus

  --        (`+'), space ( ), zero (`0'), and sharp (`#').  They can appear in

  --        any combination.

  --

  --       `-'

  --             The result of the conversion is left justified, and the right

  --             is padded with blanks.  If you do not use this flag, the

  --             result is right justified, and padded on the left.

  --

  --       `+'

  --             The result of a signed conversion (as determined by TYPE)

  --             will always begin with a plus or minus sign.  (If you do not

  --             use this flag, positive values do not begin with a plus sign.)

  --

  --       `" " (space)'

  --             If the first character of a signed conversion specification

  --             is not a sign, or if a signed conversion results in no

  --             characters, the result will begin with a space.  If the space

  --             ( ) flag and the plus (`+') flag both appear, the space flag

  --             is ignored.

  --

  --       `0'

  --             If the TYPE character is `d', `i', `o', `u', `x', `X', `e',

  --             `E', `f', `g', or `G': leading zeroes, are used to pad the

  --             field width (following any indication of sign or base); no

  --             spaces are used for padding.  If the zero (`0') and minus

  --             (`-') flags both appear, the zero (`0') flag will be ignored.

  --             For `d', `i', `o', `u', `x', and `X' conversions, if a

  --             precision PREC is specified, the zero (`0') flag is ignored.

  --             Note that `0' is interpreted as a flag, not as the beginning

  --             of a field width.

  --   

  --       `#'

  --             The result is to be converted to an alternative form,

  --             according to the next character:

  --

  --            `0'

  --                  increases precision to force the first digit of the

  --                  result to be a zero.

  --

  --            `x'

  --                  a non-zero result will have a `0x' prefix.

  --

  --            `X'

  --                  a non-zero result will have a `0X' prefix.

  --

  --            `e, E or f'

  --                  The result will always contain a decimal point even if

  --                  no digits follow the point.  (Normally, a decimal point

  --                  appears only if a digit follows it.)  Trailing zeroes

  --                  are removed.

  --

  --            `g or G'

  --                  same as `e' or `E', but trailing zeroes are not removed.

  --

  --            `all others'

  --                  undefined.

  --

  --      * WIDTH

  --

  --        WIDTH is an optional minimum field width.  You can either specify

  --        it directly as a decimal integer, or indirectly by using instead

  --        an asterisk (`*'), in which case an `int' argument is used as the

  --        field width.  Negative field widths are not supported; if you

  --        attempt to specify a negative field width, it is interpreted as a

  --        minus (`-') flag followed by a positive field width.

  --

  --      * PREC

  --

  --        an optional field; if present, it is introduced with ``.'' (a

  --        period). This field gives the maximum number of characters to

  --        print in a conversion; the minimum number of digits of an integer

  --        to print, for conversions with TYPE `d', `i', `o', `u', `x', and

  --        `X'; the maximum number of significant digits, for the `g' and `G'

  --        conversions; or the number of digits to print after the decimal

  --        point, for `e', `E', and `f' conversions.  You can specify the

  --        precision either directly as a decimal integer or indirectly by

  --        using an asterisk (`*'), in which case an `int' argument is used

  --        as the precision.  Supplying a negative precision is equivalent to

  --        omitting the precision.  If only a period is specified the

  --        precision is zero.  If a precision appears with any other

  --        conversion TYPE than those listed here, the behavior is undefined.

  --

  --      * SIZE

  --

  --        `h', `l', and `L' are optional size characters which override the

  --        default way that `printf' interprets the data type of the

  --        corresponding argument.  `h' forces the following `d', `i', `o',

  --        `u', `x' or `X' conversion TYPE to apply to a `short' or `unsigned

  --        short'. `h' also forces a following `n' TYPE to apply to a pointer

  --        to a `short'. Similarily, an `l' forces the following `d', `i',

  --        `o', `u', `x' or `X' conversion TYPE to apply to a `long' or

  --        `unsigned long'.  `l' also forces a following `n' TYPE to apply to

  --        a pointer to a `long'.  `l' with `c', `s' is equivalent to `C',

  --        `S' respectively.  If an `h' or an `l' appears with another

  --        conversion specifier, the behavior is undefined.  `L' forces a

  --        following `e', `E', `f', `g' or `G' conversion TYPE to apply to a

  --        `long double' argument.  If `L' appears with any other conversion

  --        TYPE, the behavior is undefined.

  --

  --      * TYPE

  --

  --        TYPE specifies what kind of conversion `printf' performs.  Here is

  --        a table of these:

  --

  --       `%'

  --             prints the percent character (`%')

  --

  --       `c'

  --             prints ARG as single character

  --

  --       `C'

  --             prints wchar_t ARG as single multibyte character

  --

  --       `s'

  --             prints characters until precision is reached or a null

  --             terminator is encountered; takes a string pointer

  --

  --       `S'

  --             converts wchar_t characters to multibyte output characters

  --             until precision is reached or a null wchar_t terminator is

  --             encountered; takes a wchar_t pointer

  --

  --       `d'

  --             prints a signed decimal integer; takes an `int' (same as `i')

  --

  --       `i'

  --             prints a signed decimal integer; takes an `int' (same as `d')

  --

  --       `o'

  --             prints a signed octal integer; takes an `int'

  --

  --       `u'

  --             prints an unsigned decimal integer; takes an `int'

  --

  --       `x'

  --             prints an unsigned hexadecimal integer (using `abcdef' as

  --             digits beyond `9'); takes an `int'

  --

  --       `X'

  --             prints an unsigned hexadecimal integer (using `ABCDEF' as

  --             digits beyond `9'); takes an `int'

  --

  --       `f'

  --             prints a signed value of the form `[-]9999.9999'; takes a

  --             floating-point number

  --

  --       `e'

  --             prints a signed     value of the form

  --             `[-]9.9999e[+|-]999'; takes a floating-point number

  --

  --       `E'

  --             prints the same way as `e', but using `E' to introduce the

  --             exponent; takes a floating-point number

  --

  --       `g'

  --             prints a signed value in either `f' or `e' form, based on

  --             given value and precision--trailing zeros and the decimal

  --             point are printed only if necessary; takes a floating-point

  --             number

  --

  --       `G'

  --             prints the same way as `g', but using `E' for the exponent if

  --             an exponent is needed; takes a floating-point number

  --

  --       `n'

  --             stores (in the same object) a count of the characters written;

  --             takes a pointer to `int'

  --

  --       `p'

  --             prints a pointer in an implementation-defined format.  This

  --             implementation treats the pointer as an `unsigned long' (same

  --             as `Lu').

  ------------------------------------------------------------------------------

  -- Conversion functions

  function to_integer         (value : in string) return integer;

  procedure read_identifier(file f : char_file; value : inout string_ptr);

  procedure read_integer(file f : char_file; value : out integer);

  procedure find_token(file f : char_file; value : in string);

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  -- Working with commands:

  ------------------------------------------------------------------------------

  -- First level of abstraction: tokens.

  constant max_token_size : integer := 80;

  type token_kind is

  (

    name,

    integer_number,

    end_of_line,

    end_of_file,

    start_of_comment,

    separator,

    not_recognized

  );

  type token is record

    kind      : token_kind;

    value_ptr : string_ptr;

  end record;

  procedure read_token(file f : char_file; value : inout token);

  procedure write_token(file f : char_file; value : inout token);

  --

  ------------------------------------------------------------------------------

  -- Second level of abstraction: commands.

  -- Maximum number of arguments in a command:

  constant max_args_in_command : integer := 4*1024;

  -- Command type:

  type command is record

    time_cnt : natural;               -- The time, when the command should be applied

    id       : string_ptr;            -- Pointer to the command ID.

    arg      : integer_array_ptr; -- Pointer to the array of arguments.

  end record;

  procedure read_command(file f : char_file; id : in string; cmd : inout command);

  type command_list_elem;

  type command_list_elem_ptr is access command_list_elem;

  type command_list_elem is record

    cmd      : command;

    prv      : command_list_elem_ptr;

    nxt      : command_list_elem_ptr;

  end record;

  type command_list is record

    number   : natural;

    first    : command_list_elem_ptr;

    last     : command_list_elem_ptr;

  end record;

  procedure init_command_list(fname : in string; variable clist : inout command_list; block_id : in string);

  procedure put_command(variable clist : inout command_list; cmd : inout command);

  procedure get_command(variable clist : inout command_list; cmd : inout command);

  ------------------------------------------------------------------------------

end test;

--==============================================================================

--==============================================================================

package body test is

  constant hexadecimal_chars : string(1 to 32) := "0123456789abcdef0123456789ABCDEF";

  ------------------------------------------------------------------------------

  function to_character(value : in std_logic) return character is

  begin

    case value is

      when 'U' => return 'U';

      when 'X' => return 'X';

      when '0' => return '0';

      when '1' => return '1';

      when 'Z' => return 'Z';

      when 'W' => return 'W';

      when 'L' => return 'L';

      when 'H' => return 'H';

      when '-' => return '-';

    end case;

  end function to_character;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  procedure fprint_string (file f : char_file; value : in string) is

  begin

    for i in value'low to value'high loop

      write(f, value(i));

    end loop;

  end procedure fprint_string;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  procedure print_string(value : in string) is

  begin

    fprint_string(stdout, value);

  end procedure print_string;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  procedure read_integer(file f : char_file; value : out integer) is

    variable buf  : string(1 to 256);

    variable ch0  : character;

    variable idx  : positive;

  begin

    -- Searching for first character:

    while true loop

      assert not(endfile(f)) report "read_integer(): Unexpected End Of File." severity failure;

      read(f, ch0);

      exit when ((ch0 >= '0')and(ch0 <= '9'))or(ch0 = '-');

    end loop;

    buf(1) := ch0;

    idx    := 2;

    -- Reading other characters:

    while (not(endfile(f))) loop

      read(f, ch0);

      if ((ch0 >= '0')and(ch0 <= '9'))or((ch0 >= 'a')and(ch0 <= 'f'))or((ch0 >= 'A')and(ch0 <= 'F'))or(ch0 = 'x') then

        buf(idx) := ch0;

        idx := idx + 1;

      else

        exit;

      end if;

    end loop;

    value := to_integer(buf(1 to idx - 1));

  end procedure read_integer;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  procedure read_identifier(file f : char_file; value : inout string_ptr) is

    variable buf  : string(1 to 256);

    variable ch0  : character;

    variable idx  : positive;

  begin

    -- Searching for first character:

    while true loop

      assert not(endfile(f)) report "read_identifier(): Unexpected End Of File." severity failure;

      read(f, ch0);

      exit when ((ch0 >= 'A')and(ch0 <= 'Z'))or((ch0 >= 'a')and(ch0 <= 'z'))or(ch0 = '_');

    end loop;

    buf(1) := ch0;

    idx    := 2;

    -- Reading other characters:

    while (not(endfile(f))) loop

      read(f, ch0);

      if ((ch0 >= 'A')and(ch0 <= 'Z'))or((ch0 >= 'a')and(ch0 <= 'z'))or((ch0 >= '0')and(ch0 <= '9'))or(ch0 = '_') then

        buf(idx) := ch0;

        idx := idx + 1;

      else

        exit;

      end if;

    end loop;

    deallocate(value);

    value := new string'(buf(1 to idx - 1));

  end procedure read_identifier;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  procedure find_token(file f : char_file; value : in string) is

    variable ch0  : character;

    variable idx  : positive;

  begin

    idx := value'low;

    while true loop

      assert not(endfile(f)) report "find_token(" & value & "): Unexpected End Of File." severity failure;

      read(f, ch0);

      if (ch0 = value(idx)) then

        exit when (idx = value'high);

        idx := idx + 1;

      else

        idx := value'low;

      end if;

    end loop;

  end procedure find_token;

  ------------------------------------------------------------------------------

  ------------------------------------------------------------------------------

  function to_integer(value : in string) return integer is

    variable value_local : integer := 0;

    variable start_idx   : positive;

    variable negative    : boolean;

  begin

    if (value'right > 2)and(value(1) = '0')and(value(2) = 'x') then -- hex format

      start_idx := 3;

      for i in start_idx to value'right loop

        if    (value(i) >= 'a')and(value(i) <= 'f') then

          value_local := (16 * value_local) + (character'pos(value(i)) - character'pos('a') + 10);

        elsif (value(i) >= 'A')and(value(i) <= 'F') then

          value_local := (16 * value_local) + (character'pos(value(i)) - character'pos('A') + 10);

        else

          value_local := (16 * value_local) + (character'pos(value(i)) - character'pos('0'));

        end if;

      end loop;

    else

      if (value(1) = '-') then

        negative  := true;

        start_idx := 2;

      else

        negative  := false;

        start_idx := 1;

      end if;

      for i in start_idx to value'right loop

        value_local := (10 * value_local) + (character'pos(value(i)) - character'pos('0'));

      end loop;

      if (negative) then

        value_local := (-1) * value_local;

      end if;

    end if;

    return value_local;

  end function to_integer;

  ------------------------------------------------------------------------------

  --function to_string(value : in integer; width : in positive := 1) return string is

  --  variable idx  : positive;

  --  variable buf  : string(1 to 80);

  --  variable negative : boolean := (value < 0);

  --  variable value_local : integer := abs(value);

  --begin

  --  idx := 80;

  --  if (value_local = 0) then

  --    buf(idx) := '0';

  --    idx := idx - 1;

  --  end if;

  --  while (value_local /= 0) loop

  --    buf(idx) := character'val((value_local rem 10) + character'pos('0'));

  --    value_local := value_local / 10;

  --    idx := idx - 1;

  --  end loop;

  --  if (negative) then

  --    buf(idx) := '-';

  --    idx := idx - 1;

  --  end if;

  --  while ((80 - idx) < width) loop

  --    buf(idx) := ' ';

  --    idx := idx - 1;

  --  end loop;

  --  buf(1 to (80 - idx)) := buf((1 + idx) to 80);

  --  return buf(1 to (80 - idx));

  --end function to_string;

  --function to_string(value : in std_logic_vector) return string is

  --  variable res_string : string((((value'length + 3)/4) + 2) downto 1);

  --  variable res_idx    : positive;

  --  variable hex_digit  : integer;

  --begin

  --  hex_digit := 0;

  --  res_idx   := 1;

  --  for idx in value'right to value'left loop

  --    if    (value(idx)  = '1') then

  --      hex_digit := hex_digit + 2**((idx - value'right) rem 4);

  --    elsif (value(idx) /= '0') then

  --      hex_digit := hex_digit + 100;

  --    end if;

  --    if (((idx - value'right) rem 4) = 3)or(idx = value'left) then

  --      case hex_digit is

  --        when  0     => res_string(res_idx) := '0';

  --        when  1     => res_string(res_idx) := '1';

  --        when  2     => res_string(res_idx) := '2';

  --        when  3     => res_string(res_idx) := '3';

  --        when  4     => res_string(res_idx) := '4';

  --        when  5     => res_string(res_idx) := '5';

  --        when  6     => res_string(res_idx) := '6';

  --        when  7     => res_string(res_idx) := '7';

  --        when  8     => res_string(res_idx) := '8';

  --        when  9     => res_string(res_idx) := '9';

  --        when 10     => res_string(res_idx) := 'A';

  --        when 11     => res_string(res_idx) := 'B';

  --        when 12     => res_string(res_idx) := 'C';

  --        when 13     => res_string(res_idx) := 'D';

  --        when 14     => res_string(res_idx) := 'E';

  --        when 15     => res_string(res_idx) := 'F';

  --        when others => res_string(res_idx) := 'X';

  --      end case;

  --      hex_digit := 0;

  --      res_idx   := res_idx + 1;

  --    end if;

  --  end loop;

  --  res_string(res_string'left)     := '0';

  --  res_string(res_string'left - 1) := 'x';

  --  return res_string;

  --end function to_string;

  ------------------------------------------------------------------------------

  -- Working with commands:

  ------------------------------------------------------------------------------

  -- First level of abstraction: tokens.

  procedure read_token(file f : char_file; value : inout token) is

    variable ch0  : character;

    variable idx  : integer := 1;

    variable end_of_token : boolean := false;

    variable buf  : string(1 to max_token_size);

    variable kind : token_kind;

  begin

    deallocate(value.value_ptr);

    while (idx <= max_token_size)and(end_of_token = false) loop

      if (idx = 1) then

        if endfile(f) then

          kind         := end_of_file;

          end_of_token := true;

        else

          read(f, ch0);

          next when (ch0 = ' ')or(ch0 = ht);

          buf(idx) := ch0;

          idx := idx + 1;

          if    (ch0 = '#') then

            kind         := start_of_comment;

            end_of_token := true;

          elsif ((ch0 >= '0')and(ch0 <= '9'))or(ch0 = '-') then

            kind         := integer_number;

          elsif ((ch0 >= 'A')and(ch0 <= 'Z'))or((ch0 >= 'a')and(ch0 <= 'z'))or(ch0 = '_') then

            kind         := name;

          elsif (ch0 = cr) then

            kind         := end_of_line;

          elsif (ch0 = lf) then

            kind         := end_of_line;

            end_of_token := true;

          elsif (ch0 = ',')or(ch0 = '(')or(ch0 = ')')or(ch0 = '{')or(ch0 = '}')or(ch0 = ':') then

            kind         := separator;

            end_of_token := true;

          else

            kind         := not_recognized;

            end_of_token := true;