#ifndef SWITCH_H__
#define SWITCH_H__ 1

/*---------------------------------------------------------------------------
 * Data structures used mainly by the switch code generation.
 *
 *---------------------------------------------------------------------------
 * The switch() instruction is implemented using a highly efficient table
 * lookup system. The code for the instruction is generated in two places
 * (LPC compiler and lambda compiler), therefore some of the 'internal'
 * datastructures need to be published here.
 *
 * The compiler makes sure that there is always a 'default' case
 * and that all execution paths eventually execute a F_BREAK.
 *
 * The layout created by the LPC compiler is this:
 *
 *     switch b1 a2 b2 [b3 [b4] ]
 *            instructions (sans the first byte 'i0')...
 *            l[]
 *            [c0 [c1]]
 *            a0 a1 i0
 *            v*n
 *            o*n
 *            [d0]
 *
 * b1 & 0x03 is 0, marking this switch statement as unaligned.
 * Since for an efficient search the tables v*n and o*n must be
 * 4-Byte aligned (TODO: on some machines 8-Byte), the interpreter
 * will on first execution of such a switch align it (using
 * closure:align_switch()) by arranging the bytes a0..a2 around
 * the tables. The alignment can't be done at compilation time,
 * because code generated after the switch may cause to move
 * the switch code back- or forward. The aligned layout is this:
 *
 *     switch b1 b2 [b3 [b4] ]
 *            instructions...
 *            l[]
 *            [c0 [c1]]            <-- p0 = pc + offset
 *            a0..
 *            v[]                  <-- tabstart
 *            o[]                  <-- end_tab = pc + offset + tablen
 *            ..a2                 <-- p1
 *            [d0]
 *
 *  b1 (bits 1..0) = len: the length in bytes needed to store
 *        'offset', 'tablen', 'default offset', 'o*n' and the
 *        length of lookup tables for table ranges.
 *  b1 (bits 7..2) = tablen lo
 *  c0 = tablen mid (optional)
 *  c1 = tablen hi  (optional)
 *  b2 = offset lo
 *  b3 = offset med (optional)
 *  b4 = offset hi  (optional)
 *  a0, a1 = default-case offset lo and med in host byte order
 *  d0     = default-case offset hi (optional)
 *  a2 'type' (bits 0..4): start position for search (used to index
 *                         a table with the real offsets)
 *            (bit  5)   : 0: numeric switch , 1: string switch
 *            (bits 6..7): in an unaligned switch, the true value
 *                         of <len> (b1, bits 1..0).
 *  l[]: range lookup table: each <len> bytes, network byte order
 *       (numeric switch only)
 *  v[]: case values, char* or p_int, host byte order
 *  o[]: case offsets : each <len> bytes, network byte order
 *
 * The case value table v[] holds (sorted numerically) all values
 * appearing in the case statements, both singular values and range
 * bounds. Range bound values (which are inclusive) always appear
 * next to each other.
 *
 * The offset table o[] holds the associated offset with
 * this interpretation:
 *
 *   singular cases: jump destination offsets relative to pc.
 *
 *   range cases:    the 'offset' for the lower bound is 1, the
 *                   offset for the upper bound gives the jump
 *                   destination relative to pc.
 *
 *   lookup ranges:  the 'offset' for the lower bound is 0, the
 *                   offset for the upper bound is an offset
 *                   pointing into the lookup table.
 *                   The real jump offset is then
 *                     l[o[i] + <value> - lower-bound].
 *
 *   The lookup ranges are used for an efficient implementation of
 *   sparse ranges like 'case 0: case 2: case 5: ...'.
 *---------------------------------------------------------------------------
 */

#define ZERO_AS_STR_CASE_LABEL ((char *)&main)
  /* This value is used to compile 'case 0' into switch on string types.
   * We can't use the NULL pointer for this purpose, which is used when
   * looking up a string that is not in the tabled string table and
   * therefore must not be found.
   * This value must not be misinterpreted as tabled string.
   * If the string handling is changed, this value must be adapted.
   */

#define CASE_BLOCKING_FACTOR 256 /* must be >= 2 */
   /* case_list_entry_t's are allocated in blocks of this count.
    */

/* Bitmasks and -values for selected bytes in the switch statement:
 */

/* The B1 byte: */

#define SWITCH_VALUELEN  0x03  /* Bitmask */
  /* The length in bytes needed to store 'offset', 'tablen',
   * 'default offset', 'o*n' and the length of lookup tables for table
   * ranges.
   * If the value is 0, the switch is unaligned and the value is stored
   * in SWITCH_TYPE_VALUELEN.
   */

#define SWITCH_TABLEN        0xfc  /* Bitmask */
#define SWITCH_TABLEN_SHIFT  2     /* Leftshift */
  /* The low bits of the table length.
   */

/* The TYPE byte: */

#define SWITCH_START  0x1f  /* Bitmask */
  /* Start position for search (used to index a table with the real offsets).
    */

#define SWITCH_TYPE   0x20  /* Bitflag */
  /* Flag: 0: numeric switch , 1: string switch
   */

#define SWITCH_TYPE_VALUELEN        0xc0  /* Bitmask */
#define SWITCH_TYPE_VALUELEN_SHIFT  6     /* Leftshift */
  /* In an unaligned switch, the true value of SWITCH_VALUELEN.
   */

/* --- case_list_entry_t: description of one case value ---
 */
struct case_list_entry_s
{
    case_list_entry_t *next;
    p_int key;   /* Numeric case value, or a shared string casted */
    p_int addr;
      /* Offset of the associated code from the SWITCH+1.
       * If 1: this and the next entry denote a range.
       * If 0: this and the next entry denote a sparse lookup range.
       * TODO: Make this selfcontained?
       */
    p_int line;
      /* Line number of the case. It's 0 for range ends.
       */
};

/* --- case_state_t: compilation state of one switch() ---
 */

struct case_state_s
{
    case_list_entry_t *free_block;
      /* Currently used allocation block in the case_blocks list.
       */
    case_list_entry_t *next_free;
      /* First used entry in .free_block. The blocks are used
       * from the end, and the first cl_entry is reserved to link
       * the block list.
       */
    case_list_entry_t *list0;
    case_list_entry_t *list1;
      /* Head and second element of the active case list.
       * Both elements are in direct access to handle ranges (which are
       * encoded using two entries).
       */
    case_list_entry_t *zero;
    case_state_t      *previous;
      /* The case_state of the surrounding switch(), when compiling
       * a nested switch().
       */
    p_int              default_addr;
    char               some_numeric_labels;
    char               no_string_labels;
};

/* --- Variables (in closure.c) --- */
extern case_state_t case_state;

/* TODO: Move all these functions, a generic code generator
 * TODO:: and the execution function in its own file.
 * Nice would be an oo approach using a opaque type and the
 * functions: init(), add_case(), add_range(), generate().
 * An OO approach would also easily solve the problem that sequential
 * top-level switch()s accumulate in their memory usage.
 */

/* --- Prototypes (in closure.c) --- */
extern case_list_entry_t *new_case_entry(void);
extern void free_case_blocks(void);
extern void store_case_labels( p_int total_length
                             , p_int default_addr
                             , Bool numeric
                             , case_list_entry_t *zero
                             , bytecode_p (*get_space)(p_int)
                             , void (*move_instructions)(int, p_int)
                             , void (*cerror)(const char *)
                             , void (*cerrorl)(const char *, const char*, int, int)
);

#endif  /* SWITCH_H__ */