259 lines
9.7 KiB
C
259 lines
9.7 KiB
C
#ifndef PROGRAM_H
|
|
#define PROGRAM_H
|
|
/*
|
|
* A compiled program consists of several data blocks, all allocated
|
|
* contiguously in memory to enhance the working set. During compilation,
|
|
* the blocks will be allocated separately, as the final size is
|
|
* unknown. When compilation is done, the blocks will be copied into
|
|
* the one big area.
|
|
*
|
|
* There are 5 different blocks of information for each program:
|
|
* 1. The program itself. Consists of machine code instructions for a virtual
|
|
* stack machine. The size of the program must not be bigger than
|
|
* 65535 bytes, as 16 bit pointers are used. Who would ever need a bigger
|
|
* program :-)
|
|
* 2. Function names. All local functions that has been defined or called,
|
|
* with the address of the function in the program. Inherited functions
|
|
* will be found here too, with information of how far up the inherit
|
|
* chain that the function was defined.
|
|
* 3. String table. All strings used in the program. They are all pointers
|
|
* into the shared string area. Thus, they are easily found and deallocated
|
|
* when the object is destructed.
|
|
* 4. Table of variable names. They all point into the shared string table.
|
|
* 5. Line number information. A table which tells at what address every
|
|
* line belongs to. The table has the same number of entries as the
|
|
* programs has source lines. This is used at errors, to find out the
|
|
* line number of the error. This is usually swapped out to save space.
|
|
* First entry is the length of the table.
|
|
* 6. List of inherited objects.
|
|
*/
|
|
|
|
/*
|
|
* When a new object inherits from another, all function definitions
|
|
* are copied, and all variable definitions.
|
|
* Flags below can't explicitly declared. Flags that can be declared,
|
|
* are found with TYPE_ below.
|
|
*
|
|
* When an object is compiled with type testing NAME_STRICT_TYPES, all
|
|
* types are saved of the arguments for that function during compilation.
|
|
* If the #pragma save_types is specified, then the types are saved even
|
|
* after compilation, to be used when the object is inherited.
|
|
*/
|
|
|
|
/* The semantics of the flags are currently as follows:
|
|
|
|
(1) A function is either a definition, a prototype or an undefined
|
|
function
|
|
|
|
(2) A definition is an address that executes code when
|
|
it is jumped to and finishes with a return.
|
|
The address is labeled by the following info:
|
|
function name, type, flags,number of arguments, number of locals,
|
|
argument types.
|
|
|
|
(3) A prototype does not execute code, and is basically a label with
|
|
the following info:
|
|
argument types (optionally also argument names),function name,
|
|
type, flags, number of arguments
|
|
|
|
(4) An undefined function is an unknown function that has been called or
|
|
a label that is as yet not known to be a prototype or definition
|
|
|
|
Note that the above rules apply to comments in compiler.c as well.
|
|
In particular, a known prototype is not undefined. When 'function'
|
|
by itself is used, (1) is always meant.
|
|
|
|
FUNC_INHERITED - The function entry that exists in this object actually
|
|
is a function in an object we inherited
|
|
FUNC_UNDEFINED - see (4)
|
|
FUNC_STRICT_TYPES - compiled with strict type testing
|
|
FUNC_PROTOTYPE - see (3)
|
|
FUNC_ALIAS - This entry refers us to another entry, usually because
|
|
this function was overloaded by that function
|
|
|
|
Sym
|
|
*/
|
|
#define FUNC_INHERITED 0x0001
|
|
#define FUNC_UNDEFINED 0x0002
|
|
#define FUNC_STRICT_TYPES 0x0004
|
|
#define FUNC_PROTOTYPE 0x0008
|
|
#define FUNC_TRUE_VARARGS 0x0010
|
|
#define FUNC_VARARGS 0x0020
|
|
#define FUNC_ALIAS 0x8000 /* This shouldn't be changed */
|
|
|
|
#define DECL_HIDDEN 0x0100 /* used by private vars */
|
|
#define DECL_PRIVATE 0x0200 /* Can't be inherited */
|
|
#define DECL_PROTECTED 0x0400 /* Static function or variable */
|
|
#define DECL_PUBLIC 0x0800
|
|
#define DECL_NOMASK 0x1000 /* The nomask => not redefineable */
|
|
#define DECL_NOSAVE 0x2000
|
|
#ifndef SENSIBLE_MODIFIERS
|
|
#define DECL_VISIBLE 0x4000 /* Force inherit through private */
|
|
|
|
#define DECL_ACCESS (DECL_HIDDEN | DECL_PRIVATE | DECL_PROTECTED | DECL_PUBLIC | DECL_VISIBLE)
|
|
|
|
#define DECL_MODIFY(x,y) ((((x)|(y))&DECL_VISIBLE) ? ((((x)|(y))&~DECL_ACCESS)|DECL_VISIBLE) : DECL_MODIFY2(x,y))
|
|
#else
|
|
#define DECL_ACCESS (DECL_HIDDEN | DECL_PRIVATE | DECL_PROTECTED | DECL_PUBLIC)
|
|
|
|
#define DECL_MODIFY(x,y) DECL_MODIFY2(x,y)
|
|
#endif
|
|
#define DECL_MODS (DECL_ACCESS | DECL_NOMASK | DECL_NOSAVE)
|
|
|
|
#define DECL_MODIFY2(t, mod) ((((t) & DECL_ACCESS) > ((mod) & DECL_ACCESS)) ? ((t) & ~DECL_ACCESS) | (mod) : (t) | ((mod) & ~DECL_ACCESS))
|
|
|
|
/* only the flags that should be copied up through inheritance levels */
|
|
#define FUNC_MASK (FUNC_VARARGS | FUNC_UNDEFINED | FUNC_STRICT_TYPES | FUNC_PROTOTYPE | FUNC_TRUE_VARARGS | FUNC_ALIAS | DECL_MODS)
|
|
|
|
/* a function that isn't 'real' */
|
|
#define FUNC_NO_CODE (FUNC_ALIAS | FUNC_PROTOTYPE | FUNC_UNDEFINED)
|
|
#define REAL_FUNCTION(x) (!((x) & (FUNC_ALIAS | FUNC_PROTOTYPE)))
|
|
|
|
/*
|
|
* These are or'ed in on top of the basic type.
|
|
*/
|
|
|
|
/* Note, the following restricts class_num to < 0x40 or 64 */
|
|
/* The reason for this is that vars still have a ushort type */
|
|
/* This restriction is not unreasonable, since LPC is still */
|
|
/* catered for mini-applications (compared to say, C++ or */
|
|
/* java)..for now - Sym */
|
|
|
|
#define TYPE_MOD_ARRAY 0x0040 /* Pointer to a basic type */
|
|
#define TYPE_MOD_CLASS 0x0080 /* a class */
|
|
#define CLASS_NUM_MASK 0x003f
|
|
|
|
#define LOCAL_MOD_REF 0x0100
|
|
#define LOCAL_MOD_UNUSED 0x0200
|
|
|
|
#define LOCAL_MODS (LOCAL_MOD_UNUSED|LOCAL_MOD_REF)
|
|
|
|
typedef struct {
|
|
unsigned char num_arg;
|
|
unsigned char num_local;
|
|
unsigned short f_index; /* Index in sorted function table */
|
|
} runtime_defined_t;
|
|
|
|
typedef struct {
|
|
unsigned short offset;
|
|
unsigned short function_index_offset;
|
|
} runtime_inherited_t;
|
|
|
|
typedef union {
|
|
runtime_defined_t def;
|
|
runtime_inherited_t inh;
|
|
} runtime_function_u;
|
|
|
|
typedef struct {
|
|
unsigned short first_defined;
|
|
unsigned short first_overload;
|
|
unsigned short num_compressed;
|
|
unsigned short num_deleted;
|
|
unsigned char index[1];
|
|
} compressed_offset_table_t;
|
|
|
|
#ifdef USE_32BIT_ADDRESSES
|
|
#define ADDRESS_TYPE unsigned int
|
|
#define ADDRESS_MAX UINT_MAX
|
|
#else
|
|
#define ADDRESS_TYPE unsigned short
|
|
#define ADDRESS_MAX USHRT_MAX
|
|
#endif
|
|
|
|
typedef struct {
|
|
char *funcname;
|
|
unsigned short type;
|
|
unsigned char num_arg;
|
|
unsigned char num_local;
|
|
ADDRESS_TYPE address;
|
|
#ifdef PROFILE_FUNCTIONS
|
|
unsigned long calls, self, children;
|
|
#endif
|
|
} function_t;
|
|
|
|
typedef struct {
|
|
unsigned short classname;
|
|
unsigned short type;
|
|
unsigned short size;
|
|
unsigned short index;
|
|
} class_def_t;
|
|
|
|
typedef struct {
|
|
unsigned short membername;
|
|
unsigned short type;
|
|
} class_member_entry_t;
|
|
|
|
typedef struct {
|
|
char *name;
|
|
unsigned short type; /* Type of variable. See above. TYPE_ */
|
|
} variable_t;
|
|
|
|
typedef struct {
|
|
struct program_s *prog;
|
|
unsigned short function_index_offset;
|
|
unsigned short variable_index_offset;
|
|
unsigned short type_mod;
|
|
} inherit_t;
|
|
|
|
typedef struct program_s {
|
|
const char *filename; /* Name of file that defined prog */
|
|
unsigned short flags;
|
|
unsigned short last_inherited;
|
|
unsigned PROG_REF_TYPE ref; /* Reference count */
|
|
unsigned short func_ref;
|
|
#ifdef DEBUG
|
|
int extra_ref; /* Used to verify ref count */
|
|
int extra_func_ref;
|
|
#endif
|
|
char *program; /* The binary instructions */
|
|
unsigned char *line_info; /* Line number information */
|
|
unsigned short *file_info;
|
|
int line_swap_index; /* Where line number info is swapped */
|
|
function_t *function_table;
|
|
unsigned short *function_flags; /* separate for alignment reasons */
|
|
class_def_t *classes;
|
|
class_member_entry_t *class_members;
|
|
char **strings; /* All strings uses by the program */
|
|
char **variable_table; /* variables defined by this program */
|
|
unsigned short *variable_types; /* variables defined by this program */
|
|
inherit_t *inherit; /* List of inherited prgms */
|
|
int total_size; /* Sum of all data in this struct */
|
|
/*
|
|
* The types of function arguments are saved where 'argument_types'
|
|
* points. It can be a variable number of arguments, so allocation is
|
|
* done dynamically. To know where first argument is found for function
|
|
* 'n' (number of function), use 'type_start[n]'. These two arrays will
|
|
* only be allocated if '#pragma save_types' has been specified. This
|
|
* #pragma should be specified in files that are commonly used for
|
|
* inheritance. There are several lines of code that depends on the type
|
|
* length (16 bits) of 'type_start' (sorry !).
|
|
*/
|
|
unsigned short *argument_types;
|
|
#define INDEX_START_NONE 65535
|
|
unsigned short *type_start;
|
|
/*
|
|
* And now some general size information.
|
|
*/
|
|
unsigned short heart_beat; /* Index of the heart beat function. 0 means
|
|
* no heart beat */
|
|
unsigned short program_size;/* size of this instruction code */
|
|
unsigned short num_classes;
|
|
unsigned short num_functions_defined;
|
|
unsigned short num_strings;
|
|
unsigned short num_variables_total;
|
|
unsigned short num_variables_defined;
|
|
unsigned short num_inherited;
|
|
} program_t;
|
|
|
|
extern int total_num_prog_blocks;
|
|
extern int total_prog_block_size;
|
|
void reference_prog (program_t *, const char *);
|
|
void free_prog (program_t **);
|
|
void deallocate_program (program_t *);
|
|
char *variable_name (program_t *, int);
|
|
function_t *find_func_entry (program_t *, int);
|
|
|
|
#endif
|
|
|
|
|