#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. */ /* NAME_INHERITED - The function entry that exists in this object actually is a function in an object we inherited * NAME_UNDEFINED - the function hasn't been defined yet at this level * NAME_STRICT_TYPES - compiled with strict type testing * NAME_PROTOTYPE - only a prototype has been found so far * NAME_DEF_BY_INHERIT - this function actually exists in an object we've inherited; if we don't find a function at this level we'll use that one * NAME_ALIAS - This entry refers us to another entry, usually because this function was overloaded by that function */ #define NAME_INHERITED 0x1 #define NAME_UNDEFINED 0x2 #define NAME_STRICT_TYPES 0x4 #define NAME_PROTOTYPE 0x10 #define NAME_DEF_BY_INHERIT 0x20 #define NAME_ALIAS 0x40 #define NAME_TRUE_VARARGS 0x80 /* only the flags that should be copied up through inheritance levels */ #define NAME_MASK (NAME_UNDEFINED | NAME_STRICT_TYPES | NAME_PROTOTYPE) /* a function that isn't 'real' */ #define NAME_NO_CODE (NAME_UNDEFINED | NAME_ALIAS | NAME_PROTOTYPE) #define REAL_FUNCTION(x) (!((x)->flags & (NAME_ALIAS | NAME_PROTOTYPE)) && \ (((x)->flags & NAME_DEF_BY_INHERIT) || (!((x)->flags & NAME_UNDEFINED)))) /* * These are or'ed in on top of the basic type. */ #define TYPE_MOD_ARRAY 0x0020 /* Pointer to a basic type */ #define TYPE_MOD_CLASS 0x0040 /* a class */ #define TYPE_MOD_HIDDEN 0x0080 /* used by private vars */ #define TYPE_MOD_STATIC 0x0100 /* Static function or variable */ #define TYPE_MOD_NO_MASK 0x0200 /* The nomask => not redefineable */ #define TYPE_MOD_PRIVATE 0x0800 /* Can't be inherited */ #define TYPE_MOD_PROTECTED 0x1000 #define TYPE_MOD_PUBLIC 0x2000 /* Force inherit through private */ #define TYPE_MOD_VARARGS 0x4000 /* Used for type checking */ #define TYPE_MOD_MASK (~(TYPE_MOD_STATIC | TYPE_MOD_NO_MASK |\ TYPE_MOD_PRIVATE | TYPE_MOD_PROTECTED |\ TYPE_MOD_PUBLIC | TYPE_MOD_VARARGS |\ TYPE_MOD_HIDDEN)) typedef struct { /* these two must come first */ unsigned char num_arg; /* Number of arguments needed. -1 arguments * means function not defined in this object. * Probably inherited */ unsigned char num_local; /* Number of local variables */ unsigned char flags; /* NAME_ . See above. */ /* wasted byte here if anyone needs one; plenty of room for more flags */ char *name; #ifndef LPC_TO_C unsigned short offset; /* Address of function, or inherit table * index when inherited. */ #else POINTER_INT offset; #endif unsigned short type; /* Return type of function. See below. */ /* * Used so that it is possible to quickly find this function in the * inherited program. */ unsigned short function_index_offset; #ifdef PROFILE_FUNCTIONS unsigned long calls, self, children; #endif #ifdef OPTIMIZE_FUNCTION_TABLE_SEARCH unsigned short tree_l, tree_r; /* Left and right branches. */ SIGNED short tree_b; /* Balance of subtrees. */ #endif } function_t; typedef struct { unsigned short name; unsigned short type; unsigned short size; unsigned short index; } class_def_t; typedef struct { unsigned short name; 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; } inherit_t; typedef struct program_s { char *name; /* Name of file that defined prog */ int flags; unsigned short 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 */ int id_number; /* used to associate information with this * prog block without needing to increase the * reference count */ unsigned char *line_info; /* Line number information */ unsigned short *file_info; int line_swap_index; /* Where line number info is swapped */ function_t *functions; class_def_t *classes; class_member_entry_t *class_members; #ifdef OPTIMIZE_FUNCTION_TABLE_SEARCH unsigned short tree_r; /* function table tree's 'root' */ #endif char **strings; /* All strings uses by the program */ variable_t *variable_names; /* All variables defined */ inherit_t *inherit; /* List of inherited prgms */ int total_size; /* Sum of all data in this struct */ int heart_beat; /* Index of the heart beat function. -1 means * no heart beat */ /* * 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 program_size;/* size of this instruction code */ unsigned short num_classes; unsigned short num_functions; unsigned short num_strings; unsigned short num_variables; unsigned short num_inherited; } program_t; extern int total_num_prog_blocks; extern int total_prog_block_size; void reference_prog PROT((program_t *, char *)); void free_prog PROT((program_t *, int)); void deallocate_program PROT((program_t *)); #endif