prelang.y

%{
#line 3 "prelang.y"

/* The first line is to give proper line number references. Please mail me
 * if your compiler complains about it.
 */

/*
 * This is the grammar definition of LPC. The token table is built
 * automatically by make_func. The lang.y is constructed from this file,
 * the generated token list and post_lang.y. The reason of this is that there
 * is no #include-statment that yacc recognizes.
 */
#include <inttypes.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <memory.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "config.h"
#include "lint.h"
#include "interface.h"
#include "object.h"
#include "instrs.h"
#include "incralloc.h"
#include "mstring.h"
#include "simulate.h"
#include "backend.h"
#include "lex.h"
#include "efun_table.h"

/* This is to see to it that we always go through xalloc() in main.c
   even from within the yacc-parser
*/
#ifdef malloc
#undef malloc
#endif
#define malloc xalloc

#define YYMAXDEPTH      600

#define BREAK_ON_STACK          0x40000
#define BREAK_FROM_CASE         0x80000

/* make shure that this struct has a size that is a power of two */
struct case_heap_entry { long long key; offset_t addr; short line; };
#define CASE_HEAP_ENTRY_ALIGN(offset) offset &= -sizeof(struct case_heap_entry)

static struct mem_block mem_block[NUMAREAS];

static int has_inherited;

/*
 * Some good macros to have.
 */

#define BASIC_TYPE(e,t) ((e) == TYPE_ANY ||\
                         (e) == (t) ||\
                         (t) == TYPE_ANY)

#define TYPE(e,t) (BASIC_TYPE((e) & TYPE_MASK, (t) & TYPE_MASK) ||\
                   (((e) & TYPE_MOD_POINTER) && ((t) & TYPE_MOD_POINTER) &&\
                    BASIC_TYPE((e) & (TYPE_MASK & ~TYPE_MOD_POINTER),\
                               (t) & (TYPE_MASK & ~TYPE_MOD_POINTER))))

#define FUNCTION(n) ((struct function *)mem_block[A_FUNCTIONS].block + (n))
#define VARIABLE(n) ((struct variable *)mem_block[A_VARIABLES].block + (n))
#define INHERIT(n)  ((struct inherit *)mem_block[A_INHERITS].block + (n))

#define align(x) ( ((x) + (sizeof(double)-1) )  &  ~(sizeof(double)-1) )

/*
 * If the type of the function is given, then strict types are
 * checked and required.
 */
static int exact_types;
extern int pragma_strict_types; /* Maintained by lex.c */
extern int pragma_save_binary;  /* Save this in the binary shadow dir */
extern int pragma_no_inherit;
extern int pragma_no_shadow;
extern int pragma_no_clone;
extern struct object *auto_ob;

static int true_varargs;

extern int total_num_prog_blocks, total_prog_block_size;

extern int num_parse_error;
extern int d_flag;

static offset_t current_break_address;
static offset_t current_continue_address;
static offset_t current_case_address;
static offset_t current_case_number_heap;
static offset_t current_case_string_heap;
static int try_level, break_try_level, continue_try_level;
#define SOME_NUMERIC_CASE_LABELS 0x40000
#define NO_STRING_CASE_LABELS    0x80000
static int zero_case_label;
static int current_type;

static char *get_type_name(int);

/*
 * There is always function starting at address 0, which will execute
 * the initialization code. This code is spread all over the program,
 * with jumps to next initializer. The next variable keeps track of
 * the previous jump. After the last initializer, the jump will be changed
 * into a return(0) statement instead.
 *
 * A function named '.CTOR' will be defined, which will contain the
 * initialization code. If there was no initialization code, then the
 * function will not be defined. That is the usage of the
 * first_last_initializer_end variable.
 *
 * When inheriting from another object, a call will automatically be made
 * to call .CTOR in that code from the current .CTOR.
 */
static offset_t last_initializer_end;
static offset_t first_last_initializer_end;

void epilog (void);
static int check_declared (char *str);
static void prolog (void);
static void push_address (void);
static offset_t pop_address (void);
static offset_t make_label (void);
static void transfer_init_control (void);
static char *get_two_types (int, int);
static int verify_declared (char *);
static int handle_function_id (char *);
static void copy_inherits (struct program *, int, char *);
static int check_inherits(struct program *);
static int search_for_ext_function(char *, struct program *);

static struct program NULL_program; /* marion - clean neat empty struct */

void init_lineno_info(void);
void end_lineno_info(void);
static void push_init_arg_address (offset_t);
static void clear_init_arg_stack (void);
void free_all_local_names (void);
int lookup_local_name(char *);
int add_local_name (char *, int);
void smart_log (char *, int, char *);
extern int yylex (void);
void type_error (char *, int);
char *inner_get_srccode_position(int code, struct lineno *lineno, int lineno_count,
    char *inc_files, char *name);
int search_for_function(char *name, struct program *prog);
int handle_include(char *name, int ignore_errors);

INLINE static unsigned mem_block_size(int, int);

extern int current_line;
/*
 * 'inherit_file' is used as a flag. If it is set to a string
 * after yyparse(), this string should be loaded as an object,
 * and the original object must be loaded again.
 */
extern char *current_file, *inherit_file;

/*
 * The names and types of arguments and auto variables.
 */
static unsigned short type_of_locals[MAX_LOCAL];
static int local_blockdepth[MAX_LOCAL];
static char *local_names[MAX_LOCAL];
static int current_number_of_locals = 0;
static int max_number_of_locals = 0;

/*
 * The types of arguments when calling functions must be saved,
 * to be used afterwards for checking. And because function calls
 * can be done as an argument to a function calls,
 * a stack of argument types is needed. This stack does not need to
 * be freed between compilations, but will be reused.
 */
struct mem_block type_of_arguments;

struct program *prog;   /* Is returned to the caller of yyparse */

/*
 * Compare two types, and return true if they are compatible.
 */
static int
compatible_types(int t1, int t2)
{
    if (t1 == TYPE_UNKNOWN || t2 == TYPE_UNKNOWN)
        return 0;
    if (t1 == t2)
        return 1;
    if ((t1|TYPE_MOD_NO_MASK|TYPE_MOD_STATIC|TYPE_MOD_PRIVATE|TYPE_MOD_PUBLIC)
        == (t2|TYPE_MOD_NO_MASK|TYPE_MOD_STATIC|TYPE_MOD_PRIVATE|TYPE_MOD_PUBLIC))
        return 1;
    if (t1 == TYPE_ANY || t2 == TYPE_ANY)
        return 1;
    if ((t1 & TYPE_MOD_POINTER) && (t2 & TYPE_MOD_POINTER)) {
        if ((t1 & TYPE_MASK) == (TYPE_ANY|TYPE_MOD_POINTER) ||
            (t2 & TYPE_MASK) == (TYPE_ANY|TYPE_MOD_POINTER))
            return 1;
    }
    if (t1 == TYPE_MAPPING)
        return 1;
    return 0;
}

/*
 * Add another argument type to the argument type stack
 */
INLINE
static void
add_arg_type(unsigned short type)
{
    struct mem_block *mbp = &type_of_arguments;
    while (mbp->current_size + sizeof type > mbp->max_size) {
        mbp->max_size <<= 1;
        mbp->block = realloc(mbp->block, (size_t)mbp->max_size);
    }
    (void)memcpy(mbp->block + mbp->current_size, &type, sizeof type);
    mbp->current_size += sizeof type;
}

/*
 * Pop the argument type stack 'n' elements.
 */
INLINE
static void
pop_arg_stack(int n)
{
    type_of_arguments.current_size -= sizeof (unsigned short) * n;
}

/*
 * Get type of argument number 'arg', where there are
 * 'n' arguments in total in this function call. Argument
 * 0 is the first argument.
 */
INLINE
int
get_argument_type(int arg, int n)
{
    return((unsigned short *)(type_of_arguments.block + type_of_arguments.current_size))[arg - n];
}

INLINE
static void
add_to_mem_block(int n, void *data, int size)
{
    struct mem_block *mbp = &mem_block[n];
    while (mbp->current_size + size > mbp->max_size) {
        mbp->max_size <<= 1;
        mbp->block = realloc(mbp->block, (size_t)mbp->max_size);
    }
    memcpy(mbp->block + mbp->current_size, data, (size_t)size);
    mbp->current_size += size;
}

INLINE static unsigned
mem_block_size(int n, int size)
{
    return mem_block[n].current_size / size;
}

INLINE static void
ins_byte(char b)
{
    add_to_mem_block(A_PROGRAM, &b, 1);
}

static INLINE void
upd_byte(offset_t offset, char l)
{
    mem_block[A_PROGRAM].block[offset] = l;
}

static INLINE char
read_byte(offset_t offset)
{
    return mem_block[A_PROGRAM].block[offset];
}

/*
 * Store a 2 byte number. It is stored in such a way as to be sure
 * that correct byte order is used, regardless of machine architecture.
 * Also beware that some machines can't write a word to odd addresses.
 */
static INLINE void
ins_short(int32_t t)
{
    if (t >= UINT16_MAX) {
        fatal("Attempt to insert a too large short.");
    }

    int16_t val = t;
    add_to_mem_block(A_PROGRAM, &val, sizeof(val));
}

static INLINE void
upd_address(offset_t offset, offset_t val)
{
    memcpy(&mem_block[A_PROGRAM].block[offset], &val, sizeof(val));
}

static INLINE short
read_short(offset_t offset)
{
    return *(short *)&mem_block[A_PROGRAM].block[offset];
}

static offset_t
read_address(offset_t offset)
{
    static offset_t out;
    memcpy(&out, &mem_block[A_PROGRAM].block[offset], sizeof(offset_t));
    return out;
}

static void
ins_address(offset_t l)
{
    add_to_mem_block(A_PROGRAM, &l, sizeof(l));
}


static INLINE void
ins_mem(void *data, size_t n)
{
   add_to_mem_block(A_PROGRAM, data, n);
}

static INLINE void
ins_long_long(long long ll)
{
    add_to_mem_block(A_PROGRAM, &ll, sizeof(ll));
}

/*
 * Return 1 on success, 0 on failure.
 */
static int
defined_function(char *s)
{
    int offset;
    int inh;
    struct function *funp;
    char *super_name = 0;
    char *sub_name;
    char *real_name;
    char *search;

    real_name = strrchr(s, ':') + 1;
    sub_name = strchr(s, ':') + 2;

    real_name = (find_sstring((real_name == (char *)1) ? s : real_name));
    if(!real_name) {
        return 0;
    }
    if (sub_name == (char *)2)
        for (offset = 0; offset < mem_block[A_FUNCTIONS].current_size;
             offset += sizeof (struct function))
            {
                funp = (struct function *)&mem_block[A_FUNCTIONS].block[offset];
                /* Only index, prog, and type will be defined. */
                if (real_name == funp->name)
                    {
                        function_index_found = offset / sizeof (struct function);
                        function_prog_found = 0;
                        function_type_mod_found = funp->type_flags & TYPE_MOD_MASK;
                        function_inherit_found = mem_block[A_INHERITS].current_size / sizeof(struct inherit);
                        return 1;
                    }
            }
    else
        if (sub_name - s > 2)
        {
            super_name = alloca((size_t)(sub_name - s - 1));
            (void)memcpy(super_name, s, (size_t)(sub_name - s - 2));
            super_name[sub_name - s - 2] = 0;
            if (strcmp(super_name, "this") == 0)
                return defined_function(sub_name);
        }
        else
            s = sub_name;

    /* Look for the function in the inherited programs
        */

    for (inh = mem_block[A_INHERITS].current_size / sizeof (struct inherit) - 1;
          inh >= 0; inh -= ((struct inherit *)(mem_block[A_INHERITS].block))[inh].prog->
         num_inherited)
    {
        if (super_name &&
            strcmp(super_name, ((struct inherit *)(mem_block[A_INHERITS].block))[inh].name) == 0)
            search = sub_name;
        else
            search = s;
        if (search_for_ext_function (search,
            ((struct inherit *)(mem_block[A_INHERITS].block))[inh].prog))
        {
            /* Adjust for inherit-type */
            int type = ((struct inherit *)mem_block[A_INHERITS].block)[inh].type;

            if (function_type_mod_found & TYPE_MOD_PRIVATE)
                type &= ~TYPE_MOD_PUBLIC;
            if (function_type_mod_found & TYPE_MOD_PUBLIC)
                type &= ~TYPE_MOD_PRIVATE;
            function_type_mod_found |= type & TYPE_MOD_MASK;

            function_inherit_found += inh -
                (((struct inherit *)(mem_block[A_INHERITS].block))[inh].prog->
                 num_inherited - 1);

            return 1;
        }
    }
    return 0;
}

/*
 * A mechanism to remember addresses on a stack. The size of the stack is
 * defined in config.h.
 */
static offset_t comp_stackp;
static offset_t comp_stack[COMPILER_STACK_SIZE];

static INLINE void
push_address()
{
    if (comp_stackp >= COMPILER_STACK_SIZE) {
            yyerror("Compiler stack overflow");
            comp_stackp++;
            return;
    }
    comp_stack[comp_stackp++] = mem_block[A_PROGRAM].current_size;
}

static INLINE offset_t
get_address(void)
{
    return mem_block[A_PROGRAM].current_size;
}

static INLINE void
push_explicit(offset_t address)
{
    if (comp_stackp >= COMPILER_STACK_SIZE) {
            yyerror("Compiler stack overflow");
            comp_stackp++;
            return;
    }
    comp_stack[comp_stackp++] = address;
}

static INLINE offset_t
pop_address()
{
    if (comp_stackp == 0)
        fatal("Compiler stack underflow.\n");
    if (comp_stackp > COMPILER_STACK_SIZE) {
            --comp_stackp;
            return 0;
    }
    offset_t ret = comp_stack[--comp_stackp];
    return ret;
}

static INLINE void
add_jump(void)
{
    offset_t offset = mem_block[A_PROGRAM].current_size;
    add_to_mem_block(A_JUMPS, (char *)&offset, sizeof (offset));
}

static void
define_new_function(char *name, char num_arg, unsigned char num_local, offset_t offset, int type_flags, char first_default)
{
    struct function fun;
    struct function *funp;
    unsigned short argument_start_index;

    if (defined_function (name))
    {
        /* The function is already defined.
         *   If it was defined by inheritance, make a new definition,
         *   unless nomask applies.
         *   If it was defined in the current program, use that definition.
         */
         /* Point to the function definition found
          */
        if (function_prog_found)
        {
            funp = &function_prog_found->functions[function_index_found];
        }
        else
            funp = FUNCTION(function_index_found);

        /* If it was declared in the current program, and not a prototype,
         * it is a double definition.
         */
        if (!(funp->type_flags & NAME_PROTOTYPE) &&
            !function_prog_found)
        {
            char buff[500];

            (void)snprintf(buff, sizeof(buff), "Redeclaration of function %s", name);
            yyerror (buff);
            return;
        }

        /* If neither the new nor the old definition is a prototype,
         * it must be a redefinition of an inherited function.
         * Check for nomask.
         */
        if ((funp->type_flags & TYPE_MOD_NO_MASK) &&
            !(funp->type_flags & NAME_PROTOTYPE))
        {
            char buff[500];

            (void)snprintf(buff, sizeof(buff), "Illegal to redefine nomask function %s", name);
            yyerror (buff);
            return;
        }

        /* Check types
         */
        if (exact_types &&
            ((funp->type_flags & TYPE_MASK) != TYPE_UNKNOWN))
        {
            if (funp->num_arg != num_arg &&
                !(funp->type_flags & TYPE_MOD_VARARGS))
            {
                yyerror("Incorrect number of arguments");
                return;
            }
/*
 * This is just a nuisance! /JnA

            else if (!(funp->type_flags & NAME_STRICT_TYPES))
            {
                yyerror("Function called not compiled with type testing");
                return;
            }
*/

#if 0
            else
            {
                int i;
                /* Now check argument types
                 */
                for (i=0; i < num_arg; i++)
                {
                }
            }
#endif
        }
        /* If it is a prototype for a function that has already been defined,
         * we don't need it.
         */
        if ((type_flags & NAME_PROTOTYPE) && !function_prog_found)
            return;

        /* If the function was defined in an inherited program, we need to
         * make a new definition here.
         */
        if (function_prog_found) {
            funp = &fun;
        }
    }
    else { /* Function was not defined before, we need a new definition */
        funp = &fun;
    }

#ifdef PROFILE_LPC
    funp->num_calls = 0;
    funp->time_spent = 0;
    funp->tot_time_spent = 0;
    funp->avg_calls = 0;
    funp->avg_time = 0;
    funp->avg_tot_time = 0;
    funp->last_call_update = 0;
#endif
    funp->offset = offset;
    funp->type_flags = type_flags;
    funp->num_arg = num_arg;
    funp->num_local = num_local;
    funp->first_default = first_default;
    funp->hash_idx = -1;
    if (exact_types)
        funp->type_flags |= NAME_STRICT_TYPES;

    if (!exact_types || num_arg == 0) {
            argument_start_index = INDEX_START_NONE;
    }
    else
    {
        int i;
        /*
         * Save the start of argument types.
         */
        argument_start_index =
            mem_block[A_ARGUMENT_TYPES].current_size /
                sizeof (unsigned short);
        for (i=0; i < num_arg; i++)
            add_to_mem_block(A_ARGUMENT_TYPES, (char *)&type_of_locals[i],
                             sizeof type_of_locals[i]);
    }
    if (funp == &fun)
    {
        funp->name = make_sstring(name);
        add_to_mem_block (A_FUNCTIONS, (char *)&fun, sizeof fun);
        add_to_mem_block(A_ARGUMENT_INDEX, (char *)&argument_start_index,
                    sizeof argument_start_index);
    }
    else
    {
        (void)memcpy(&mem_block[A_ARGUMENT_INDEX].
                     block[function_index_found * sizeof(argument_start_index)],
                     (char *)&argument_start_index, sizeof(argument_start_index));
    }
    return;
}

static INLINE int
is_simul_efun (char *name)
{

    if (simul_efun_ob != 0 && search_for_function (name, simul_efun_ob->prog) &&
        !(function_type_mod_found & (TYPE_MOD_PRIVATE | TYPE_MOD_STATIC)))
        return 1;
    return 0;
}

static void
define_variable(char *name, int type)
{
    struct variable dummy;
    int n;

    n = check_declared(name);
    if (n != -1 && (n & TYPE_MOD_NO_MASK))
    {
        char *p = (char *)alloca(80 + strlen(name));
        (void)sprintf(p, "Illegal to redefine 'nomask' variable \"%s\"", name);
        yyerror(p);
    }

    dummy.name = make_sstring(name);
    dummy.type = type;
    variable_index_found = mem_block_size(A_VARIABLES,sizeof(struct variable));
    variable_inherit_found = 255;
    add_to_mem_block(A_VARIABLES, (char *)&dummy, sizeof dummy);
}

unsigned short
store_prog_string(char *str)
{
    unsigned short addr;
    int i;

    for (i = mem_block[A_STRTAB].current_size - sizeof(short); i >= 0; i -= sizeof(short))
    {
        char *str2;
        unsigned short offset;
        ((char *)&offset)[0] = mem_block[A_STRTAB].block[i];
        ((char *)&offset)[1] = mem_block[A_STRTAB].block[i + 1];
        str2 = mem_block[A_RODATA].block + offset;
        if (strcmp(str, str2) == 0)
            return offset;
    }
    if (mem_block[A_RODATA].current_size >= 0x10000)
    {
        yyerror("Too large rodata segment!\n");
        mem_block[A_RODATA].current_size = 0;
    }
    addr = mem_block[A_RODATA].current_size;

    add_to_mem_block(A_STRTAB, (char *)&addr, sizeof(addr));
    add_to_mem_block(A_RODATA, str, (int)strlen(str) + 1);
    return addr;
}

struct label
{
    offset_t address;
    offset_t link;
};

#define EMPTY_LABEL     (OFFSET_MAX - 1)

static offset_t
make_label()
{
    static struct label lbl = { EMPTY_LABEL, EMPTY_LABEL };
    offset_t ret;

    ret = mem_block[A_LABELS].current_size / sizeof(struct label);
    add_to_mem_block(A_LABELS, (char *)&lbl, sizeof(lbl));
    return ret;
}

static void
ins_label(offset_t lbl)
{
    struct label *l;

    offset_t here = mem_block[A_PROGRAM].current_size;
    l = &((struct label *)mem_block[A_LABELS].block)[lbl];
    if (l->address != EMPTY_LABEL)
            ins_address(l->address);
    else
    {
            ins_address(l->link);
            l->link = here;
    }
}

static void
set_label(offset_t lbl, offset_t addr)
{
    struct label *l;
    offset_t link1, next;

    l = ((struct label *)mem_block[A_LABELS].block) + lbl;
    l->address = addr;

    for (link1 = l->link; link1 != EMPTY_LABEL; link1 = next)
    {
            next = read_address(link1);
            upd_address(link1, addr);
    }

    l->link = EMPTY_LABEL;
}


static INLINE long long cmp_case_keys(struct case_heap_entry *entry1,
                                struct case_heap_entry *entry2, int is_str)
{
    if (is_str)
        return strcmp(mem_block[A_RODATA].block + (unsigned short)entry1->key,
                      mem_block[A_RODATA].block + (unsigned short)entry2->key);
    else
        return entry1->key - entry2->key;
}

void
add_to_case_heap(int block_index, struct case_heap_entry *entry, struct case_heap_entry *entry2)
{
    int current_heap;
    struct case_heap_entry *heap_top, *heap_entry;
    int is_str;
    int from, to, size;

    if (block_index == A_CASE_NUMBERS )
    {
        current_heap = current_case_number_heap;
        is_str = 0;
    }
    else
    {
            current_heap = current_case_string_heap;
        is_str = 1;
    }

    if (entry2 && cmp_case_keys(entry, entry2, is_str) > 0)
        return;

    heap_top = (struct case_heap_entry *)(mem_block[block_index].block + mem_block[block_index].current_size);
    heap_entry = (struct case_heap_entry *)(mem_block[block_index].block + current_heap);

    for (; heap_entry < heap_top; heap_entry++)
    {
        if (cmp_case_keys(heap_entry, entry, is_str) > 0)
            break;

        if (heap_entry->addr == OFFSET_MAX)
        {
        /* Range entry, compare next also */
            if (cmp_case_keys(++heap_entry, entry, is_str) >= 0)
            {
                /* Duplicate case label! */
                char buff[100];

                (void)sprintf(buff, "Duplicate case label (line %d)",
                        heap_entry->line);
                yyerror(buff);
                break;
            }
        }
    }

    if (heap_entry < heap_top &&
        (!cmp_case_keys(heap_entry, entry, is_str) ||
         (entry2 && (cmp_case_keys(entry2, heap_entry, is_str) >= 0))))
    {
        /* Duplicate case label! */
        char buff[100];

        (void)sprintf(buff, "Duplicate case label (line %d)",
                heap_entry->line);
        yyerror(buff);
    }


    to = ((char *)(heap_entry + 1 + (entry2 != NULL))) -
        mem_block[block_index].block;
    from = ((char *)heap_entry) - mem_block[block_index].block;
    size = (heap_top - heap_entry) * sizeof(*entry);

    add_to_mem_block(block_index, (char *)entry, sizeof(*entry));
    if (entry2)
        add_to_mem_block(block_index, (char *)entry2, sizeof(*entry2));

    if (heap_entry != heap_top)
    {
        (void)memmove(mem_block[block_index].block + to,
                      mem_block[block_index].block + from, (size_t)size);
        (void)memcpy(mem_block[block_index].block + from, entry, sizeof(*entry));
        if (entry2)
            (void)memcpy(mem_block[block_index].block + from + sizeof(*entry),
                         entry2, sizeof(*entry));
    }
}

/*
 * Arrange a jump to the current position for the initialization code
 * to continue.
 */
static void
transfer_init_control()
{
    if (mem_block[A_PROGRAM].current_size - 2 == last_initializer_end) {
            mem_block[A_PROGRAM].current_size -= 3;
    }
    else
    {
        /*
         * Change the address of the last jump after the last
         * initializer to this point.
         */
            upd_address(last_initializer_end, mem_block[A_PROGRAM].current_size);
    }
}

#define DEREFSIZE 256
static int deref_stack[DEREFSIZE];
static int deref_index;

void add_new_init_jump(void);
static offset_t init_arg_stack[256];
static int init_arg_stack_index;

static void INLINE
clear_init_arg_stack()
{
    init_arg_stack_index = 0;
}

static void INLINE
push_init_arg_address(offset_t address)
{
    init_arg_stack[init_arg_stack_index++] = address;
}

static void ins_f_byte(unsigned int);

/* ARGSUSED1 */
void
dump_init_arg_table(int arg)
{
    int i;
#if defined(DEBUG)
    if (num_parse_error == 0 && init_arg_stack_index != arg)
        fatal("Not correct number of init addresses!\n");
#endif
    for (i = 0; i < init_arg_stack_index; i++)
        ins_address(init_arg_stack[i]);
}

%}

/*
 * These values are used by the stack machine, and can not be directly
 * called from LPC.
 */
%token F_EXT F_JUMP F_JUMP_WHEN_ZERO F_JUMP_WHEN_NON_ZERO F_SKIP_NZ
%token F_POP_VALUE F_DUP
%token F_CALL_NON_VIRT F_CALL_VIRT
%token F_PUSH_IDENTIFIER_LVALUE F_PUSH_LOCAL_VARIABLE_LVALUE
%token F_PUSH_INDEXED_LVALUE F_INDIRECT F_INDEX
%token F_CONST0 F_CONST1
%token F_CALL_VAR F_BUILD_CLOSURE F_PAPPLY
/*
 * These are the predefined functions that can be accessed from LPC.
 */

%token F_IDENTIFIER
%token F_RETURN F_STRING F_FLOATC
%token F_INC F_DEC
%token F_POST_INC F_POST_DEC
%token F_NUMBER F_ASSIGN F_ADD F_SUBTRACT F_MULTIPLY
%token F_DIVIDE F_LT F_GT F_EQ F_GE F_LE
%token F_NE
%token F_ADD_EQ F_SUB_EQ F_DIV_EQ F_MULT_EQ
%token F_NEGATE
%token F_SWITCH
%token F_SSCANF F_PARSE_COMMAND F_STRING_DECL F_LOCAL_NAME
%token F_MOD F_MOD_EQ
%token F_STATIC
%token F_ARROW F_AGGREGATE F_M_AGGREGATE
%token F_COMPL F_AND F_AND_EQ F_OR F_OR_EQ F_XOR F_XOR_EQ
%token F_LSH F_LSH_EQ F_RSH F_RSH_EQ F_NOT
%token F_TRY F_END_TRY F_FOREACH F_FOREACH_M
%token F_CATCH F_END_CATCH F_CALL_C F_CALL_SIMUL
%token F_RANGE F_THROW