/*
 * Copyright (C) 2003, 2004, 2005, 2014, 2015 Filip Pizlo. 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 FILIP PIZLO ``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 FILIP PIZLO 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. 
 */

#ifndef FP_GPC_H
#define FP_GPC_H

#include "tsf.h"
#include <stdio.h>

/* this enumeration must contain the same instructions in the same order
 * as gpc_spec.in. */
enum gpc_cell {
    
    /* figure this might as well be here for completeness */
    GPC_I_NOP,
    
    /* label instruction.  this is translated into a nop.  but
     * it contains a label 'number' as an operand.  these numbers
     * do not have to be unique.  whenever a label is used, it will be
     * translated into a jump to the nearest label instruction that has
     * that label as its operand, by searching either in the forward or
     * backward direction, depending on whether or not it is a forward
     * or backward jump. */
    GPC_I_LABEL,
    
    /* we wrap up the useful subset of tsf_internal.h's converting
     * copy macros and then add conversion to them.  the operands are
     * as follows:
     * COPY_xTOyz_INCabc <offset>
     * The effect is that the pointer at the top of the stack has
     * offset added to it; in the case of INCDST, this serves as the
     * source, while for INCSRC it serves as the destination. */
    GPC_I_COPY_HTONC_INCDST,
    GPC_I_COPY_HTONS_INCDST,
    GPC_I_COPY_HTONL_INCDST,
    GPC_I_COPY_HTONLL_INCDST,
    GPC_I_COPY_HTONF_INCDST,
    GPC_I_COPY_HTOND_INCDST,
    
    GPC_I_COPY_HTONCHOICE_TO_UI8_INCDST,

    /* the rules:
     * -> if we do not change size or reduce size, we can ignore the
     *    size.
     * -> if we expand, then the signedness of the original determines
     *    whether or not we do sign expansion.
     * -> if expanding floats to ints, the signedness of the target
     *    matters (though I'm not sure why - this is only a conservative
     *    estimate based on looking at the things that gcc does for
     *    float to int conversion).
     */
    GPC_I_COPY_NTOHC_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHC_INCSRC,
    GPC_I_COPY_NTOHC_TO_S_Z_INCSRC,
    GPC_I_COPY_NTOHC_TO_S_E_INCSRC,
    GPC_I_COPY_NTOHC_TO_L_Z_INCSRC,
    GPC_I_COPY_NTOHC_TO_L_E_INCSRC,
    GPC_I_COPY_NTOHC_TO_LL_Z_INCSRC,
    GPC_I_COPY_NTOHC_TO_LL_E_INCSRC,
    GPC_I_COPY_NTOHC_TO_F_Z_INCSRC,
    GPC_I_COPY_NTOHC_TO_F_E_INCSRC,
    GPC_I_COPY_NTOHC_TO_D_Z_INCSRC,
    GPC_I_COPY_NTOHC_TO_D_E_INCSRC,

    GPC_I_COPY_NTOHS_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHS_TO_C_INCSRC,
    GPC_I_COPY_NTOHS_INCSRC,
    GPC_I_COPY_NTOHS_TO_L_Z_INCSRC,
    GPC_I_COPY_NTOHS_TO_L_E_INCSRC,
    GPC_I_COPY_NTOHS_TO_LL_Z_INCSRC,
    GPC_I_COPY_NTOHS_TO_LL_E_INCSRC,
    GPC_I_COPY_NTOHS_TO_F_Z_INCSRC,
    GPC_I_COPY_NTOHS_TO_F_E_INCSRC,
    GPC_I_COPY_NTOHS_TO_D_Z_INCSRC,
    GPC_I_COPY_NTOHS_TO_D_E_INCSRC,
    
    GPC_I_COPY_NTOHL_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHL_TO_C_INCSRC,
    GPC_I_COPY_NTOHL_TO_S_INCSRC,
    GPC_I_COPY_NTOHL_INCSRC,
    GPC_I_COPY_NTOHL_TO_LL_Z_INCSRC,
    GPC_I_COPY_NTOHL_TO_LL_E_INCSRC,
    GPC_I_COPY_NTOHL_TO_F_Z_INCSRC,
    GPC_I_COPY_NTOHL_TO_F_E_INCSRC,
    GPC_I_COPY_NTOHL_TO_D_Z_INCSRC,
    GPC_I_COPY_NTOHL_TO_D_E_INCSRC,
    
    GPC_I_COPY_NTOHLL_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHLL_TO_C_INCSRC,
    GPC_I_COPY_NTOHLL_TO_S_INCSRC,
    GPC_I_COPY_NTOHLL_TO_L_INCSRC,
    GPC_I_COPY_NTOHLL_INCSRC,
    GPC_I_COPY_NTOHLL_TO_F_Z_INCSRC,
    GPC_I_COPY_NTOHLL_TO_F_E_INCSRC,
    GPC_I_COPY_NTOHLL_TO_D_Z_INCSRC,
    GPC_I_COPY_NTOHLL_TO_D_E_INCSRC,
    
    GPC_I_COPY_NTOHF_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHF_TO_C_Z_INCSRC,
    GPC_I_COPY_NTOHF_TO_C_E_INCSRC,
    GPC_I_COPY_NTOHF_TO_S_Z_INCSRC,
    GPC_I_COPY_NTOHF_TO_S_E_INCSRC,
    GPC_I_COPY_NTOHF_TO_L_Z_INCSRC,
    GPC_I_COPY_NTOHF_TO_L_E_INCSRC,
    GPC_I_COPY_NTOHF_TO_LL_Z_INCSRC,
    GPC_I_COPY_NTOHF_TO_LL_E_INCSRC,
    GPC_I_COPY_NTOHF_INCSRC,
    GPC_I_COPY_NTOHF_TO_D_INCSRC,
    
    GPC_I_COPY_NTOHD_TO_BIT_INCSRC,
    GPC_I_COPY_NTOHD_TO_C_Z_INCSRC,
    GPC_I_COPY_NTOHD_TO_C_E_INCSRC,
    GPC_I_COPY_NTOHD_TO_S_Z_INCSRC,
    GPC_I_COPY_NTOHD_TO_S_E_INCSRC,
    GPC_I_COPY_NTOHD_TO_L_Z_INCSRC,
    GPC_I_COPY_NTOHD_TO_L_E_INCSRC,
    GPC_I_COPY_NTOHD_TO_LL_Z_INCSRC,
    GPC_I_COPY_NTOHD_TO_LL_E_INCSRC,
    GPC_I_COPY_NTOHD_TO_F_INCSRC,
    GPC_I_COPY_NTOHD_INCSRC,
    
    /* below are convert and copy routines between two pointers and
     * offsets; these are designed for primitives.  the data is copied
     * from the given offset from the topmost pointer to the given offset
     * from the second-to-topmost pointer.  call these guys like so:
     * GPC_I_COPY_x_TO_y <dest offset> <source offset> */
    GPC_I_COPY_BIT, /* makes non-zero values one - good for converting to and
		       from bits */
    GPC_I_COPY_BIT_TO_S,
    GPC_I_COPY_BIT_TO_L,
    GPC_I_COPY_BIT_TO_LL,
    GPC_I_COPY_BIT_TO_F,
    GPC_I_COPY_BIT_TO_D,
    
    GPC_I_COPY_C,
    GPC_I_COPY_C_TO_S_Z,
    GPC_I_COPY_C_TO_S_E,
    GPC_I_COPY_C_TO_L_Z,
    GPC_I_COPY_C_TO_L_E,
    GPC_I_COPY_C_TO_LL_Z,
    GPC_I_COPY_C_TO_LL_E,
    GPC_I_COPY_C_TO_F_Z,
    GPC_I_COPY_C_TO_F_E,
    GPC_I_COPY_C_TO_D_Z,
    GPC_I_COPY_C_TO_D_E,

    GPC_I_COPY_S_TO_BIT,
    GPC_I_COPY_S_TO_C,
    GPC_I_COPY_S,
    GPC_I_COPY_S_TO_L_Z,
    GPC_I_COPY_S_TO_L_E,
    GPC_I_COPY_S_TO_LL_Z,
    GPC_I_COPY_S_TO_LL_E,
    GPC_I_COPY_S_TO_F_Z,
    GPC_I_COPY_S_TO_F_E,
    GPC_I_COPY_S_TO_D_Z,
    GPC_I_COPY_S_TO_D_E,
    
    GPC_I_COPY_L_TO_BIT,
    GPC_I_COPY_L_TO_C,
    GPC_I_COPY_L_TO_S,
    GPC_I_COPY_L,
    GPC_I_COPY_L_TO_LL_Z,
    GPC_I_COPY_L_TO_LL_E,
    GPC_I_COPY_L_TO_F_Z,
    GPC_I_COPY_L_TO_F_E,
    GPC_I_COPY_L_TO_D_Z,
    GPC_I_COPY_L_TO_D_E,
    
    GPC_I_COPY_LL_TO_BIT,
    GPC_I_COPY_LL_TO_C,
    GPC_I_COPY_LL_TO_S,
    GPC_I_COPY_LL_TO_L,
    GPC_I_COPY_LL,
    GPC_I_COPY_LL_TO_F_Z,
    GPC_I_COPY_LL_TO_F_E,
    GPC_I_COPY_LL_TO_D_Z,
    GPC_I_COPY_LL_TO_D_E,
    
    GPC_I_COPY_F_TO_BIT,
    GPC_I_COPY_F_TO_C_Z,
    GPC_I_COPY_F_TO_C_E,
    GPC_I_COPY_F_TO_S_Z,
    GPC_I_COPY_F_TO_S_E,
    GPC_I_COPY_F_TO_L_Z,
    GPC_I_COPY_F_TO_L_E,
    GPC_I_COPY_F_TO_LL_Z,
    GPC_I_COPY_F_TO_LL_E,
    GPC_I_COPY_F,
    GPC_I_COPY_F_TO_D,
    
    GPC_I_COPY_D_TO_BIT,
    GPC_I_COPY_D_TO_C_Z,
    GPC_I_COPY_D_TO_C_E,
    GPC_I_COPY_D_TO_S_Z,
    GPC_I_COPY_D_TO_S_E,
    GPC_I_COPY_D_TO_L_Z,
    GPC_I_COPY_D_TO_L_E,
    GPC_I_COPY_D_TO_LL_Z,
    GPC_I_COPY_D_TO_LL_E,
    GPC_I_COPY_D_TO_F,
    GPC_I_COPY_D,
    
    /* note that there are no 64-bit set operations.  this is the
     * result of cells possibly being 32-bit instead of 64-bit. */

    /* set operations.  these take a constant off the stream and
     * shove it into the requested offset from the ptr
     * on top of the stack.  use it like so:
     * GPC_I_SET_XX <dest offset> <constant> */
    GPC_I_SET_C,
    GPC_I_SET_S,
    GPC_I_SET_L,
    
    /* set operations.  these take a constant off the stream and
     * shove it into the requested offset from the ptr that is
     * second from top of the stack.  use it like so:
     * GPC_I_SET_2ND_XX <dest offset> <constant> */
    GPC_I_SET_2ND_C,
    GPC_I_SET_2ND_S,
    GPC_I_SET_2ND_L,
    
    /* note that the read instructions below all increment the
     * current buffer pointer register. */
    
    /* do a bitvector read.  the tsf_native_bitvector_t structure is
     * at the given offset from the topmost pointer.  call this like so:
     * GPC_I_BITVECTOR_READ <offset> */
    GPC_I_BITVECTOR_READ,
    
    /* bitvector read that converts the bitvector to something other than
     * a bitvector */
    GPC_I_BITVECTOR_READ_TO_C,
    GPC_I_BITVECTOR_READ_TO_S,
    GPC_I_BITVECTOR_READ_TO_L,
    GPC_I_BITVECTOR_READ_TO_LL,
    GPC_I_BITVECTOR_READ_TO_F,
    GPC_I_BITVECTOR_READ_TO_D,
    
    /* bitvector read that converts something other than a bitvector into
     * a bitvector */
    GPC_I_BITVECTOR_READ_FROM_C,
    GPC_I_BITVECTOR_READ_FROM_S,
    GPC_I_BITVECTOR_READ_FROM_L,
    GPC_I_BITVECTOR_READ_FROM_LL,
    GPC_I_BITVECTOR_READ_FROM_F,
    GPC_I_BITVECTOR_READ_FROM_D,
    
    GPC_I_BITVECTOR_READ_FROM_TSF_INTEGER_ARRAY,
    GPC_I_BITVECTOR_READ_FROM_TSF_LONG_ARRAY,

    /* do a bitvector write.  the tsf_native_bitvector_t structure is at
     * the given offset from the topmost pointer.  call this like so:
     * GPC_I_BITVECTOR_WRITE <offset> */
    GPC_I_BITVECTOR_WRITE,
    
    /* do a byte array read.  the tsf_native_array_t structure is at the
     * given offset from the topmost pointer.  the length is multiplied
     * by the given multiplier to obtain the size of the array in bytes.
     * call this like so:
     * GPC_I_BYTE_ARRAY_READ <offset> <multiplier> */
    GPC_I_BYTE_ARRAY_READ,
    
    /* do a byte array write.  the tsf_native_array_t structure is at the
     * given offset from the topmost pointer.  the length is multiplied
     * by the given multiplier to obtain the size of the array in bytes.
     * call this like so:
     * GPC_I_BYTE_ARRAY_WRITE <offset> <multiplier> */
    GPC_I_BYTE_ARRAY_WRITE,
    
    /* What follows are instructions for supporting TSF integers. See the
     * comment above the declaration of TSF_TK_INTEGER in tsf.h. */
    
    /* skip a TSF integer. */
    GPC_I_TSF_INTEGER_SKIP,
    GPC_I_TSF_UNSIGNED_SKIP,
    GPC_I_TSF_LONG_SKIP,
    
    /* read a TSF integer and convert to a variety of things. */
    GPC_I_TSF_INTEGER_READ_TO_BIT,
    GPC_I_TSF_INTEGER_READ_TO_C,
    GPC_I_TSF_INTEGER_READ_TO_S,
    GPC_I_TSF_INTEGER_READ,
    GPC_I_TSF_INTEGER_READ_TO_LL,
    GPC_I_TSF_INTEGER_READ_TO_F,
    GPC_I_TSF_INTEGER_READ_TO_D,
    GPC_I_TSF_UNSIGNED_READ_SUB1, /* reads onto the stack, not into memory. */
    GPC_I_TSF_LONG_READ_TO_BIT,
    GPC_I_TSF_LONG_READ_TO_C,
    GPC_I_TSF_LONG_READ_TO_S,
    GPC_I_TSF_LONG_READ_TO_L,
    GPC_I_TSF_LONG_READ,
    GPC_I_TSF_LONG_READ_TO_F,
    GPC_I_TSF_LONG_READ_TO_D,
    
    /* increment the size register for a TSF integer. */
    GPC_I_TSF_INTEGER_SIZE,
    GPC_I_TSF_UNSIGNED_PLUS1_SIZE,
    GPC_I_TSF_LONG_SIZE,
    
    /* write a TSF integer. */
    GPC_I_TSF_INTEGER_WRITE,
    GPC_I_TSF_UNSIGNED_PLUS1_WRITE,
    GPC_I_TSF_LONG_WRITE,
    
    /* set the string to the empty string.  the char* is at the given
     * offset from the topmost pointer. */
    GPC_I_STRING_SETEMPTY,
    
    /* do a string read.  the char* is at the given offset from the
     * topmost pointer. */
    GPC_I_STRING_READ,
    
    /* do a string skip. */
    GPC_I_STRING_SKIP,
    
    /* calculate the size for a string.  the char* is at the given offset
     * from the topmost pointer. */
    GPC_I_STRING_SIZE,
    
    /* do a string write.  the char* is at the given offset from the
     * topmost pointer. */
    GPC_I_STRING_WRITE,
    
    /* do a string copy.  the second to topmost pointer plus the 
     * destination offset points to the destination char*, while the
     * topmost pointer plus source offset points to the source char*.
     * call this like so:
     * GPC_I_STRING_COPY <dest offset> <src offset> */
    GPC_I_STRING_COPY,

    /* set the buffer to a buffer just containing void.  the tsf_buffer_t*
     * is at the given offset frm the topmost pointer. */
    GPC_I_ANY_SETEMPTY,
    
    /* do an any read.  the tsf_buffer_t* is at the given offset from the
     * topmost pointer. */
    GPC_I_ANY_READ,
    
    /* do an any skip. */
    GPC_I_ANY_SKIP,
    
    /* calculate the size of an any.  the tsf_buffer_t* is at the given
     * offset frm the topmost pointer. */
    GPC_I_ANY_SIZE,
    
    /* do an any write.  the tsf_buffer_t* is at the given offset from the
     * topmost pointer. */
    GPC_I_ANY_WRITE,
    
    /* do an any copy.  the second to topmost pointer plus the destination
     * offset points to the destination tsf_buffer_t*, while the topmost
     * pointer plus source offset points to the source tsf_buffer_t*.  call
     * this like so:
     * GPC_I_ANY_COPY <dest offset> <src offset> */
    GPC_I_ANY_COPY,
    
    /* do a memcpy from one data structure to another.  the
     * destination is second to topmost, while the source is topmost.
     * the operands are: offset from destination, offset from source, and
     * the size. */
    GPC_I_MEMCPY,
    
    /* copy an array.  the second to topmost pointer plus the
     * destination offset points to the destination tsf_native_array_t,
     * while the topmost pointer plus source offset points to the source
     * tsf_native_array_t.  the other operand is the multiplier that
     * specifies the number of bytes for each array element. call this
     * like so:
     * GPC_I_COPY_ARRAY <dest offset> <src offset> <multiplier> */
    GPC_I_COPY_ARRAY,
    
    /* copy a bitvector.  the second to topmost pointer plus the
     * destination offset points to the destination tsf_native_bitvector_t,
     * while the topmost pointer plus source offset points to the source
     * tsf_native_bitvector_t. call this like so:
     * GPC_I_COPY_ARRAY <dest offset> <src offset> */
    GPC_I_COPY_BITVECTOR,
    
    /* copy between bitvectors and other types of arrays */
    GPC_I_COPY_BITVECTOR_FROM_C,
    GPC_I_COPY_BITVECTOR_FROM_S,
    GPC_I_COPY_BITVECTOR_FROM_L,
    GPC_I_COPY_BITVECTOR_FROM_LL,
    GPC_I_COPY_BITVECTOR_FROM_F,
    GPC_I_COPY_BITVECTOR_FROM_D,
    GPC_I_COPY_BITVECTOR_TO_C,
    GPC_I_COPY_BITVECTOR_TO_S,
    GPC_I_COPY_BITVECTOR_TO_L,
    GPC_I_COPY_BITVECTOR_TO_LL,
    GPC_I_COPY_BITVECTOR_TO_F,
    GPC_I_COPY_BITVECTOR_TO_D,
    
    /* read a 8-bit value and place it on the stack.  if the value was
     * 255, it is instead converted to UINT32_MAX. */
    GPC_I_READC_TO_CHOICE,

    /* read a 32-bit value and place it at the top of the stack. */
    GPC_I_READL,
    
    /* do an array length write.  operand is the offset from the
     * topmost pointer to the 32-bit array length.  relevant
     * bounds checks are done. */
    GPC_I_ARRAY_LEN_WRITE_FIELD,
    
    /* do an array length read.  operand is the offset from the
     * topmost pointer to the 32-bit array length.  relevant
     * bounds checks are done. */
    GPC_I_ARRAY_LEN_READ_FIELD,
    
    /* do an array length read.  the array length is pushed onto
     * the stack.  relevant bounds checks are done. */
    GPC_I_ARRAY_LEN_READ_LOCAL,
    
    /* do an array length read.  discard the array length. */
    GPC_I_ARRAY_LEN_SKIP,
    
    /* if the 8-bit value pointed to by the specified offset from
     * the topmost pointer is non-zero, set set specified bit in
     * the current buffer location.  otherwise reset it.  the
     * buffer pointer is not advanced.   you call this thing as
     * follows:
     * GPC_I_BIT_MASK_WRITE <bit index> <offset> */
    GPC_I_BIT_MASK_WRITE,
    
    /* mask out the requested bit from the current buffer location
     * without advancing the pointer.  if set, then set the 8-bit
     * value pointed to by the specified offset from the topmost
     * pointer to 1; otherwise, set it to 0.  this instruction is
     * used as follows:
     * GPC_I_BIT_MASK_READ <bit index> <offset> */
    GPC_I_BIT_MASK_READ,
    
    /* same but store it in something other than a byte. */
    GPC_I_BIT_MASK_READ_TO_S,
    GPC_I_BIT_MASK_READ_TO_L,
    GPC_I_BIT_MASK_READ_TO_LL,
    GPC_I_BIT_MASK_READ_TO_F,
    GPC_I_BIT_MASK_READ_TO_D,
    
    /* write a bit stored in a byte.  the idea is that the value
     * is 'normalized', or converted to either a 1 or 0 prior to
     * being placed into the buffer.  the only argument is the
     * offset. */
    GPC_I_BIT_WRITE,
    
    /* read a bit store it in a byte.  the idea is that the value is
     * 'normalized', or converted to either a 1 or 0 prior to being
     * placed into the user's data structure.  the only argument is
     * the offset. */
    GPC_I_BIT_READ,
    
    /* read a bit store it in something other than a byte. */
    GPC_I_BIT_READ_TO_S,
    GPC_I_BIT_READ_TO_L,
    GPC_I_BIT_READ_TO_LL,
    GPC_I_BIT_READ_TO_F,
    GPC_I_BIT_READ_TO_D,
    
    /* skip some number of bytes. operand is the number of bytes. */
    GPC_I_SKIP,
    
    /* skip an array; the operands are the size of each element, and
     * an offset from the topmost pointer.  the array length is found
     * at that offset.  call this like so:
     * GPC_I_ARRAY_BC_AND_SKIP_FIELD <offset> <multiplier> */
    GPC_I_ARRAY_BC_AND_SKIP_FIELD,
    
    /* skip an array; this instruction reads the array length, does
     * relevant bounds checks, and skips the array.  all it needs to
     * know is the number of bytes required by each array element.
     * call this like so:
     * GPC_I_ARRAY_SKIP <constant> */
    GPC_I_ARRAY_SKIP,
    
    /* skip a bitvector; the operand is the offset from the topmost
     * pointer where the number of bits can be found. */
    GPC_I_BITVECTOR_BC_AND_SKIP_FIELD,
    
    /* skip a bitvector; this instruction reads the array length, does
     * relevant bounds checks, and skips the bitvector.  this
     * instruction takes no operands. */
    GPC_I_BITVECTOR_SKIP,
    
    /* increment the size register by the specified number of bytes. */
    GPC_I_INC_SIZE,
    
    /* examine the array length at the given offset from the topmost
     * pointer, and increment the size register by the number of
     * bytes that this array length would occupy in the stream. */
    GPC_I_INC_SIZE_ARRAY_LEN,
    
    /* increment the size register by the size of the array, where the
     * second operand is the size in bytes of each element and the
     * first operand is an offset to a tsf_native_array_t structure. */
    GPC_I_INC_SIZE_ARRAY,
    
    /* increment the size register to accomodate the number of bits
     * as specified by the 32-bit value at the given offset from the
     * topmost pointer. */
    GPC_I_INC_SIZE_BITVECTOR,
    
    /* bounds check.  bounds check failure leads to termination of
     * the interpreter with an error.  operand is the number of
     * bytes we expect to be able to see. */
    GPC_I_BC,
    
    /* array bounds check.  bounds check failure leads to termination
     * of the interpreter with an error.  operands are a size
     * constant and the offset from the topmost pointer to the
     * length of the array (32-bit).  if constant*array_len bytes
     * are not available, the bounds check fails.  call this like so:
     * GPC_I_ARRAY_BC_FIELD <offset> <multiplier> */
    GPC_I_ARRAY_BC_FIELD,
    
    /* array bounds check.  bounds check failure leads to termination
     * of the interpreter with an error.  operand is a size
     * constant.  the array length is the topmost stack element.  if
     * constant*array_len bytes are not available, the bounds check
     * fails. */
    GPC_I_ARRAY_BC_LOCAL,
    
    /* bitvector bounds check.  bounds check failure leads to termination
     * of the interpreter with an error.  the operand is the offset
     * from the topmost pointer to a 32-bit number of bits.  if
     * (num_bits+7)>>3 bytes are not available, the bounds check fails.
     */
    GPC_I_BITVECTOR_BC_FIELD,
    
    /* bitvector bounds check.  bounds check failure leads to termination
     * of the interpreter with an error.  the number of bits is the
     * topmost element on the stack.  if (num_bits+7)>>3 bytes are not
     * available, the bounds check fails.
     */
    GPC_I_BITVECTOR_BC_LOCAL,
    
    /* malloc a buffer.  will be automatically deallocated upon
     * interpreter failure or if it is not returned.  if allocation
     * fails, the interpreter fails.  the allocation size is determined
     * by the size register.  performing this allocation automatically sets
     * the end register so that bounds checks can be performed. */
    GPC_I_MALLOC_BUF,
    
    /* pop the buffer off the stack.  the current pointer, the buffer
     * pointer, the end pointer, the keep bit, and the types pointer are
     * all set.  however, size is not set (so you cannot do a MALLOC_BUF
     * after this call). */
    GPC_I_POP_BUF,
    
    /* destroy a buffer. */
    GPC_I_DESTROY_BUFFER,
    
    /* create an output map. */
    GPC_I_MAKE_OUT_MAP,
    
    /* examine the second-to-top-most pointer.  if it is NULL, then perform a
     * region alloc and replace the second-to-top-most pointer with the result.
     * if the region pointer was NULL, then it is replaced with the result as
     * well, and the region is put into keep mode.  the only operand is the
     * size. */
    GPC_I_ALLOC_ROOT_MAYBE_2ND,
    
    /* allocate and push.  this is a region alloc.  failure here
     * leads to termination of the interpreter.  the operand is
     * the size. */
    GPC_I_ALLOC,
    
    /* allocate and push array.  this is a region alloc.  failure here
     * leads to termination of the interpreter.  the operands are
     * the element size and the offset from the topmost pointer to
     * the tsf_native_array_t.  tsf_native_array_t::len should be set
     * already, and is used to determine how many bytes to alloc.
     * tsf_native_array_t::data will be set to the same thing that
     * gets pushed -- that is, the newly allocated array.  call this like
     * so: 
     * GPC_I_ALLOC_ARRAY <offset> <multiplier> */
    GPC_I_ALLOC_ARRAY,
    
    /* allocate and push array.  this is a region alloc.  failure here
     * leads to termination of the interpreter.  the operands are
     * the element size and the offset from the second to topmost pointer to
     * the tsf_native_array_t.  tsf_native_array_t::len should be set
     * already, and is used to determine how many bytes to alloc.
     * tsf_native_array_t::data will be set to the same thing that
     * gets pushed -- that is, the newly allocated array.  call this like
     * so: 
     * GPC_I_ALLOC_ARRAY <offset> <multiplier> */
    GPC_I_ALLOC_ARRAY_2ND,

    /* call a function of the form void(*)(void*), passing it the given
     * offset from the topmost pointer.  call it like so:
     * GPC_I_CALL <offset> <function pointer> */
    GPC_I_CALL,

    /* add callback to current region.  callback must be of the form
     * void(*)(void*).  the argument is computed as an offset from the
     * topmost pointer.  call it like so:
     * GPC_I_ADD_CBACK <offset> <function pointer> */
    GPC_I_ADD_CBACK,
    
    /* call free with the top of the stack. */
    GPC_I_FREE_IMMEDIATE,
    
    /* call free with the the pointer loaded from stack top + offset. */
    GPC_I_FREE,
    
    /* store the topmost pointer at the given offset from the second-to-
     * topmost pointer. */
    GPC_I_STORE_PTR,
    
    /* store the topmost pointer at the given offset from the third-to-
     * topmost pointer. */
    GPC_I_STORE_PTR_2ND,
    
    /* store the topmost value at the given offset from the second-to-
     * topmost pointer. */
    GPC_I_STORE_VAL,
    
    /* push a pointer onto the stack.  operand is an
     * offset from current top-most pointer where this pointer
     * can be found. */
    GPC_I_PUSH_PTR,
    
    /* push a pointer onto the stack.  operand is an
     * offset from current second-to-top-most pointer where this pointer
     * can be found. */
    GPC_I_PUSH_PTR_2ND,
    
    /* push a pointer onto the stack.  operand is an
     * offset from current third-to-top-most pointer where this pointer
     * can be found. */
    GPC_I_PUSH_PTR_3RD,
    
    /* push a 32-bit value onto the stack.  operand is an
     * offset from current top-most pointer where this
     * value can be found. */
    GPC_I_PUSH_VAL,

    /* dup the second-to-topmost pointer */
    GPC_I_DUP_PTR_2ND,
    
    /* pop a pointer or value from the stack. */
    GPC_I_POP,
    
    /* pop two things off the stack. */
    GPC_I_TWO_POP,
    
    /* pop three things off the stack. */
    GPC_I_THREE_POP,
    
    /* first, save the topmost pointer in a register.  then, add the
     * 32-bit value stored at an offset from the second to
     * topmost pointer multiplied by the supplied constant to the topmost
     * pointer.  finally, push the saved pointer onto the stack.
     * this weird instruction looks like this:
     * GPC_I_MULADD_PTR <offset> <constant>
     * What the heck does this instruction really do?  It sets you up
     * for a pointer loop! */
    GPC_I_REPUSH_MULADD_PTR,
    
    /* first, save the topmost pointer in a register.  then, add the
     * 32-bit value stored at an offset from the third to
     * topmost pointer multiplied by the supplied constant to the topmost
     * pointer.  finally, push the saved pointer onto the stack.
     * this weird instruction looks like this:
     * GPC_I_MULADD_PTR <offset> <constant> */
    GPC_I_REPUSH_MULADD_PTR_2ND,
    
    /* compare (less-than) the topmost pointer to the next-to-topmost
     * pointer.  if the comparison fails, jump to the given label.
     * this is a forward jump. */
    GPC_I_COMPFAILJUMP,
    
    /* compare (less-than) the second to topmost pointer to the third
     * to topmost pointer.  if the comparison fails, jump to the given
     * label.  this is a forward jump. */
    GPC_I_COMPFAILJUMP_2ND,
    
    /* add the given constant to the topmost pointer, compare it
     * (less-than) to the next-to-topmost pointer, and if the
     * comparison is true, jump to the given label.  note that
     * this is a backward branch, so the label is looked for
     * backwards, not forwards.  here's how to call it:
     * GPC_I_ADDCOMPJUMP <constant> <label> */
    GPC_I_ADDCOMPJUMP,
    
    /* add the destination constant to the second-to-topmost pointer,
     * add the source constant to the topmost pointer, compare the
     * second-to-topmost pointer to the third-to-topmost pointer, and
     * if the comparison is true, jump to the given label.  note that
     * this is a backward branch, so the label is looked for backwards,
     * not forwards.  here's how to call it:
     * GPC_I_TWO_ADDCOMPJUMP <dest const> <src const> <label> */
    GPC_I_TWO_ADDCOMPJUMP,
    
    /* if the topmost value on the stack is zero, jump forward to
     * the given label. */
    GPC_I_ZEROJUMP,
    
    /* decrement the value at the top of the stack.  if it is non-zero,
     * jump backward to the given label. */
    GPC_I_DECCOMPJUMP,
    
    /* compares the topmost element on the stack to the supplied constant.
     * if the topmost element is UINT32_MAX, nothing happens.  if the
     * topmost element is less than the supplied constant, nothing happens.
     * otherwise, it is an error, and the interpreter fails out. */
    GPC_I_CHECKCHOICE,
    
    /* pop the 32-bit value at the top of the stack
     * and use it as an index into the given table, and then place
     * the looked up value into the location pointed to by the topmost
     * pointer plus the offset.  here's the way you call this beast:
     * GPC_I_TABLESET_LOCAL_TO_FIELD <offset> <num table entries>
     *                               <entry 0> <entry 1> ...
     * If the value at the top of the stack is beyond the bounds of
     * this table, then it is an error and the interpreter is
     * terminated.  If the value is UINT32_MAX, then the location is
     * set to UINT32_MAX. */
    GPC_I_TABLESET_LOCAL_TO_FIELD,
    
    /* read the 32-bit value at the given source offset from the
     * topmost pointer and use it as an index into the given table, and
     * then place the looked up value into the location pointed to by
     * the destination offset plus the second to topmost pointer.
     * call this like so:
     * GPC_I_TABLESET_FIELD_TO_FIELD <dest offset> <source offset>
     *                               <num table entries> <entry 0> ...
     * If the value at the given offset from the topmost pointer is
     * beyond the bounds of this table, then it is an error and the
     * interpreter is terminated.  If the value is UINT32_MAX, then the
     * location is set to UINT32_MAX. */
    GPC_I_TABLESET_FIELD_TO_FIELD,
    
    /* retrieve the 32-bit value from the offset off of the topmost
     * pointer and use it as an index into the given table, and then jump
     * to the location labeled by the looked up value.  You call this
     * beast like so:
     * GPC_I_TABLEJUMP_FIELD <offset> <num table entries> <entry 0> ...
     * If the value at the given offset from the topmost pointer is
     * beyond the bounds of this table, then it is an error and the
     * interpreter is terminated.  If the value is UINT32_MAX, then no
     * jump occurs. */
    GPC_I_TABLEJUMP_FIELD,
    
    /* pop the 32-bit value at the top of the stack and
     * use it as an index into the given table, and then jump to the
     * location labeled by the looked up value.  You call this
     * beast like so:
     * GPC_I_TABLEJUMP <num table entries> <entry 0> ...
     * If the value at the topmost pointer is beyond the bounds of
     * this table, then it is an error and the interpreter is
     * terminated.  If the value is UINT32_MAX, then no jump occurs. */
    GPC_I_TABLEJUMP_LOCAL,
    
    /* jump to the given label unconditionally.  this is a forward jump */
    GPC_I_JUMP,
    
    /* returns one. */
    GPC_I_RETURN_ONE,
    
    /* returns the top pointer without clearing the region. */
    GPC_I_RETURN_TOP_WITH_REGION,
    
    /* assumes that the buffer that the client sees is in the stack slot just
     * below the top one. initializes it with the resulting data buffer and sets
     * the types to the type_in_man empty singleton. */
    GPC_I_RETURN_ONE_INIT_BUF_WITH_EMPTY_TYPES,
    
    /* assumes that the buffer that the client sees is in the stack slot just
     * below the top one. initializes it with the resulting data buffer and the
     * inverse of the current running out_map. */
    GPC_I_RETURN_ONE_INIT_BUF_WITH_TYPES_FROM_OUT_MAP,
    
    /* this is not a real instruction.  don't use it.  but make sure that
     * it is always at the end of this enumeration. */
    GPC_I_LAST
};

typedef uintptr_t gpc_cell_t;

/* a list of cell pointers */
struct gpc_cell_list {
    gpc_cell_t *cell;
    struct gpc_cell_list *next;
};

typedef struct gpc_cell_list gpc_cell_list_t;

/* contains GPC_I_LABEL instructions. */
struct gpc_proto {
    uint32_t num_args;
    gpc_cell_t *stream;
    uint32_t size;  /* number of cells allocated for stream.  this is also
                     * the number of cells that have code in them. */
};

/* does not contain GPC_I_LABEL instructions. */
struct gpc_intable {
    uint32_t num_args;
    gpc_cell_t *stream;
    uint32_t size;  /* number of cells allocated for stream.  this is also
                     * the number of cells that have code in them. */

    tsf_st_table *targets;

    tsf_st_table *stack_heights;
    intptr_t max_height;
};

typedef struct gpc_intable gpc_intable_t;

/* threaded code */
struct gpc_threaded {
    uint32_t num_args;
    gpc_cell_t *stream;
    uint32_t size;  /* number of cells allocated for stream.  this is also
                     * the number of cells that have code in them. */
    intptr_t max_height;
};

typedef struct gpc_threaded gpc_threaded_t;

/* the type for a function that implements running a gpc_program. */
typedef uintptr_t (*gpc_program_runner_t)(void *payload,
                                          void *region,
                                          gpc_cell_t *args);

/* the type of a function that desrtroys the payload of a gpc_program. */
typedef void (*gpc_program_destroyer_t)(void *payload);

/* this is what you use to run a GPC program.  delegates to one
 * of the execution engines. */
struct gpc_program {
    void *payload;
    gpc_program_runner_t runner;
    gpc_program_destroyer_t destroyer;
};

/* returns the size, in the number of slots, that this instruction
 * occupies.  note that some instructions are variable length.  for
 * these instructions, this macro returns UINT32_MAX.
 * FIXME: this macro is wrong.  the nh copy opcodes take one
 * operand, not two. */
uint32_t gpc_instruction_static_size(gpc_cell_t inst);

/* returns the effect on the stack from executing this instruction.
 * if 0 is returned, that means that the stack height is unaffected.  if
 * a positive number is returned, then the stack will grow by that amount.
 * if a negative number is returned, then the stack will shrink by that
 * amount. */
int32_t gpc_instruction_stack_effects(gpc_cell_t inst);

/* return a string with the name of the instruction. */
const char *gpc_instruction_to_string(gpc_cell_t inst);

/* returns the size, in the number of slots, that this instruction
 * occupies.  note that some instructions are variable length.  for
 * this reason, this macro requires that you pass in a pointer to
 * an instruction in the actual stream, so that the instruction
 * stream can be properly queried. */
uint32_t gpc_instruction_size(gpc_cell_t *instptr);

/* function to execute for jump targets within instructions */
typedef tsf_bool_t (*gpc_target_cback_t)(gpc_cell_t *cell,void *arg);

/* executes the given jump target callback for all back branches in
 * the given instruction. */
tsf_bool_t gpc_instruction_for_all_back_branches(gpc_cell_t *inst,
                                                 gpc_target_cback_t cback,
                                                 void *arg);

/* executes the given jump target callback for all forward branches in
 * the given instruction. */
tsf_bool_t gpc_instruction_for_all_forward_branches(gpc_cell_t *inst,
                                                    gpc_target_cback_t cback,
                                                    void *arg);

/* executes the given jump target callback for all branches in
 * the given instruction. */
tsf_bool_t gpc_instruction_for_all_branches(gpc_cell_t *inst,
                                            gpc_target_cback_t cback,
                                            void *arg);

/* returns tsf_true if the given instruction causes the program to
 * return. */
tsf_bool_t gpc_instruction_is_return(gpc_cell_t inst);

/* returns tsf_true if the given instruction may allow control flow
 * to continue to the instruction directly after it.  returns tsf_false
 * for instructions that do unconditional jumps and that terminate the
 * program, or for anything else that will never lead to control flow
 * continuing to the next instruction. */
tsf_bool_t gpc_instruction_is_continuous(gpc_cell_t inst);

/* create a prototype.  this is just the beginning of the creation
 * process.  it is then your responsibility to drop in the proper
 * opcodes and operands. */
gpc_proto_t *gpc_proto_create(uint32_t num_args);

/* destroy a prototype. */
void gpc_proto_destroy(gpc_proto_t *proto);

/* get the number of arguments */
#define gpc_proto_get_num_args(proto) \
            ((proto)->num_args)

/* reserve the specified number of additional slots. */
tsf_bool_t gpc_proto_reserve(gpc_proto_t *proto,
                             uint32_t num_slots);

/* append an instruction.  you are required to supply the correct
 * number of operands. */
tsf_bool_t gpc_proto_append(gpc_proto_t *proto,
                            gpc_cell_t inst,
                            ...);

/* append a tableset_local_to_field instruction */
tsf_bool_t gpc_proto_append_tableset_local_to_field(gpc_proto_t *proto,
                                                    gpc_cell_t offset,
                                                    gpc_cell_t num,
                                                    const gpc_cell_t *args);

/* append a tableset_field_to_field instruction */
tsf_bool_t gpc_proto_append_tableset_field_to_field(gpc_proto_t *proto,
                                                    gpc_cell_t dest_offset,
                                                    gpc_cell_t src_offset,
                                                    gpc_cell_t num,
                                                    const gpc_cell_t *args);

/* append a tablejump_local instruction */
tsf_bool_t gpc_proto_append_tablejump_local(gpc_proto_t *proto,
                                            gpc_cell_t num,
                                            const gpc_cell_t *args);

/* append a tablejump_local instruction */
tsf_bool_t gpc_proto_append_tablejump_field(gpc_proto_t *proto,
                                            gpc_cell_t offset,
                                            gpc_cell_t num,
                                            const gpc_cell_t *args);

/* print the prototype to the given FILE stream. */
void gpc_proto_print(gpc_proto_t *proto,
                     FILE *out);

/* debugging stuff */
void gpc_code_gen_debug(const char *type,
                        gpc_proto_t *proto);

/* create an interpretable from a prototype. */
gpc_intable_t *gpc_intable_from_proto(gpc_proto_t *proto);

/* clone an interpretable */
gpc_intable_t *gpc_intable_clone(gpc_intable_t *intable);

/* destroy an interpretable. */
void gpc_intable_destroy(gpc_intable_t *intable);

/* get the number of arguments */
#define gpc_intable_get_num_args(intable) \
            ((intable)->num_args)

/* get the beginning of the intable stream */
#define gpc_intable_get_stream(intable) \
            ((intable)->stream)

/* get the end (STL-style) of the intable stream */
#define gpc_intable_get_stream_end(intable) \
            ((intable)->stream+(intable)->size)

/* returns tsf_true if the given cell address is a jump target */
#define gpc_intable_is_target(intable,address) \
            (tsf_st_lookup((intable)->targets,(char*)address,NULL))

/* returns tsf_true if the given cell address is live code */
#define gpc_intable_is_live(intable,address) \
            (tsf_st_lookup((intable)->stack_heights,(char*)address,NULL))

/* returns the stack height at the given piece of code.  will return
   -1 if the code is not live.  note that the error code is not set in
   either case. */
intptr_t gpc_intable_get_height(gpc_intable_t *prog,
				gpc_cell_t *address);

/* returns tsf_true if gpc_intable_run is supported. */
tsf_bool_t gpc_intable_run_supported();

/* interpret the intable. */
uintptr_t gpc_intable_run(gpc_intable_t *prog,
                          void *region,
                          gpc_cell_t *args);

/* write the program using the given writer. */
tsf_bool_t gpc_intable_write(gpc_intable_t *prog,
			     tsf_writer_t writer,
			     void *arg);

/* NOTE: the all_returns, predecessors, and min_remaining analyses are
 * currently unused and so hence are excluded from the Makefile and from
 * the distribution.  They are, however, included in CVS, lest they ever
 * become useful. */

/* analysis to find all returns.  returns a NULL-terminated array of return
 * points in the given program.
 *
 * FIXME: this really should not be a separate analysis.  it should be just
 * an extra return from gpc_intable_get_predecessors(). */
gpc_cell_t **gpc_intable_find_all_returns(gpc_intable_t *prog);

/* find predecessors.  returns a hashtable mapping each instruction cell
 * to a linked list of its predecessors.  the linked list is typed as a
 * gpc_cell_list_t. */
tsf_st_table *gpc_intable_get_predecessors(gpc_intable_t *prog);

/* you should use this function to free up the list returned by the
 * gpc_intable_get_predecessors() function. */
void gpc_intable_destroy_predecessors(tsf_st_table *preds);

/* gives you a table that maps each instruction to the minimum number of
 * bytes that you are guaranteed to have left in the buffer, assuming
 * that the program does not overrun the buffer in the end. */
tsf_st_table *gpc_intable_get_min_remaining(gpc_intable_t *prog);

/* return true if the given intable ever does integer to float
 * conversion. */
tsf_bool_t gpc_intable_can_do_int_to_float_conversion(gpc_intable_t *prog);

/* returns tsf_true if the given intable ever calls functions that require
 * a pointer to the buffer pointer register. */
tsf_bool_t gpc_intable_can_call_buffer_mutator_functions(gpc_intable_t *prog);

/* returns tsf_true if the given intable ever uses the in_map (also
   known as types).  definitions of in_map don't con't - so this will
   return tsf_false if the intable defines but does not use the
   in_map. */
tsf_bool_t gpc_intable_can_use_in_map(gpc_intable_t *prog);

/* returns tsf_true if the given intable ever uses the out_map.
   definitions of out_map don't con't - so this will return tsf_false
   if the intable defines but does not use the out_map. */
tsf_bool_t gpc_intable_can_use_out_map(gpc_intable_t *prog);

/* returns tsf_true if gpc_threaded_t is supported. */
tsf_bool_t gpc_threaded_supported();

/* create a threaded program from an intable.  this may fail if GPC
 * was compiled with a compiler that does not support the address-of-
 * label extension. */
gpc_threaded_t *gpc_threaded_from_intable(gpc_intable_t *intable);

/* destroy a threaded */
void gpc_threaded_destroy(gpc_threaded_t *threaded);

/* get the number of arguments */
#define gpc_threaded_get_num_args(threaded) \
            ((threaded)->num_args)

/* run a threaded */
uintptr_t gpc_threaded_run(gpc_threaded_t *prog,
                           void *region,
                           gpc_cell_t *args);

/* create a program using the engine of your choice.  if you pass in
 * TSF_EN_DEFAULT, then the default engine is used (based on the
 * TSF_ENGINE_CONFIG environment variable; if it is not set, then
 * the default is GPINT).  if you pass in TSF_EN_NOT_SUPPORTED, then
 * NULL is returned without the error being set (this allows for error
 * propagation). */
gpc_program_t *gpc_program_from_proto(gpc_proto_t *proto);

/* same as above but create from an intable. */
gpc_program_t *gpc_program_from_intable(gpc_intable_t *intable);

/* destroy a program */
void gpc_program_destroy(gpc_program_t *prog);

/* run a program */
uintptr_t gpc_program_run(gpc_program_t *prog,
                          void *region,
                          gpc_cell_t *args);

#endif