TPL_DATA.H

common declarations

/*-------------------------------------------------------------------*
     Common Declarations

     File:     tpl_data.h

     Module:   common

     by:  Stephen R. Schmitt
 *-------------------------------------------------------------------*/

/*
 * define DEBUG for debugging
 */
//#define DEBUG

#ifdef DEBUG
 #define D(x) x
#else
 #define NDEBUG                                     // assert() not compiled
 #define D(x)
#endif

/*
 *   Defined constants
 */
#define EOF_CHAR                       3
#define CR_CHAR                       13
#define LF_CHAR                       10
#define TAB_CHAR                       9
#define FF_CHAR                       12
#define BS_CHAR                        8
#define TAB_SIZE                       8
#define MIN_KEY_WORD_LENGTH            2
#define MAX_KEY_WORD_LENGTH           10
#define MAX_FILES                     16
#define FILE_NAME_LENGTH              32
#define TOKEN_STRING_LENGTH           64
#define SIGNATURE                  11111
#define NESTING_LEVELS                16
#define MAX_STRING_LENGTH            255
#define MAX_STACK_SIZE               512
#define MAX_CODE_SIZE               1024
#define MAX_CODE_SEGMENTS           1024
#define MAX_LABELS                  1024

#ifdef DEBUG
 #define MAX_ARRAY_SIZE             1024
 #define MAX_DATA_SIZE              1024
#else
 #define MAX_ARRAY_SIZE             4096
 #define MAX_DATA_SIZE              8191
#endif

#define MAX_BREAKS                     8
#define SCREEN_TOP                     2
#define SCREEN_BOTTOM                 25

typedef enum
{
    false = 0, true = 1
}
bool;

struct line
{
    struct line *prev;
    struct line *next;
    char *string;
};

/*--------------------------------------------------------------------*
			 Token structure
 *--------------------------------------------------------------------*/

typedef enum
{
    NO_TOKEN, ID_TOKEN, INT_TOKEN, REAL_TOKEN,
    STR_TOKEN, CHAR_TOKEN, END_OF_FILE, ERR_TOKEN,
    COMMA, PERIOD, ELLIPSES, COLON, AMPERSAND,
    ASSIGN, PLUS, MINUS, STAR, SLASH, CARET,
    EQ, NE, LT, LE, GT, GE,
    L_PAREN, R_PAREN,
    ABS, AND, ARCCOS, ARCSIN, ARCTAN, ARCTANXY, ARRAY, ASSERT,
    BOOLEAN,
    CASE, CEIL, CHAR, CHR, CLOSE, CONST, CONTINUE, COS, COSH, CURSOR,
    DECREASING, DIV, DO,
    ELSE, ELSIF, END, ENUM, EOFF, EREALSTR, EXIT, EXP,
    FALSE, FLOOR, FOR, FREALSTR, FUNCTION,
    GET, GETEXP, GETKEY, GOTO,
    IF, INCLUDE, INDEX, INT, INTREAL, INTSTR,
    LABEL, LENGTH, LN, LOCATE, LOG2, LOG10, LOOP,
    MAX, MIN, MOD,
    NAND, NOR, NOT,
    OF, OPEN, OR, ORD,
    PRED, PROCEDURE, PROGRAM, PUT, PUTCH, PUTSTR, PUTLINE, PUTPIXEL,
    RAND, RANDINT, RANDOMIZE, RANDSEED, REAL, REALSTR,
    RECORD, REPEAT, RETURN, ROUND,
    SCROLL, SETEXP, SETVIDEO, SIGN, SIN, SINH, SQRT,
    STRING, STRINT, STRREAL, SUCC,
    TAN, TANH, THEN,
    TRUE, TYPE,
    UNION,
    VALUE, VAR, VIDEOMODE, VIDEOTYPE,
    WATCH, WHEN,
    XOR
}
TOKEN_CODE;

struct token_struct
{
    TOKEN_CODE  code;
    union
    {
        long     integer;
        double   real;
        char     lexeme[ MAX_STRING_LENGTH + 1];
    };
    char         file[ FILE_NAME_LENGTH];
    int          line;
    int          column;
};

/*--------------------------------------------------------------------*
			 Symbol table
 *--------------------------------------------------------------------*/

typedef enum
{
    NO_FORM,
    SCALER_FORM, STRING_FORM, ENUM_FORM,
    ARRAY_FORM, RECORD_FORM, UNION_FORM
}
TYPE_FORM;

typedef struct type_struct
{
    TYPE_FORM form;
    int size;
    struct symtab_node *type_idp;
    union
    {
        struct
        {
            int max;
            struct symtab_node *field_symtab;
            struct symtab_node *first_idp;
        }
        enumeration;

        struct
        {
            int max_index;
            int val_index;
            struct type_struct *next_indexp;
            struct type_struct *elmt_typep;
        }
        array;

        struct
        {
            struct symtab_node *field_symtab;
        }
        record_struct;

        struct
        {
            struct symtab_node *field_symtab;
        }
        union_struct;
    };
}
TYPE_STRUCT, *TYPE_STRUCT_PTR;

typedef enum
{
    UNDEFINED,
    CONST_DEFN, TYPE_DEFN, VAR_DEFN, LABEL_DEFN, 
    FIELD_DEFN, VALPARM_DEFN, VARPARM_DEFN, 
    MAIN_DEFN, PROG_DEFN, PROC_DEFN, FUNC_DEFN,
}
DEFN_KEY;

typedef struct symtab_node
{
    symtab_node *left;                              // ptr to left node
    symtab_node *right;                             // ptr to right node
    symtab_node *next;                              // ptr to next node
    symtab_node *prev;                              // ptr to previous node
    char *name;                                     // ptr to id name string

    TYPE_STRUCT_PTR typep;                          // ptr to id type struct

    DEFN_KEY definition;                            // type definition
    union                                           // type definition info
    {
        int integer;                                // enum value
        int data_offset;                            // offset of record field
        struct
        {
            int parm_count;                         // of formal parameters
            int segment;                            // segment number
            char file[FILE_NAME_LENGTH];            // file declared in
            int line;                               // line declared on
        }
        routine;
    };

    bool initialized;                               // true if assigned to
}
SYMTAB_NODE, *SYMTAB_NODE_PTR;

/*--------------------------------------------------------------------*
			 Intermediate code
 *--------------------------------------------------------------------*/

typedef enum
{
    NO_CODE, STATEMENT, EXITZ, SKIP, UNSKIP,
    PUSH, POP, REG_BP, ADDR, ADDR_ADDR,
    IMM_64, IMM_32, IMM_16, IMM_8, IMM_STR,
    MEM_64, MEM_32, MEM_16, MEM_8, MEM_STR,
    MEM_64_xi, MEM_32_xi, MEM_16_xi, MEM_8_xi, 
    MEM_STR_8_xi, MEM_STR_xi,
    PTR_64, PTR_32, PTR_16, PTR_8, PTR_STR,
    PTR_64_xi, PTR_32_xi, PTR_16_xi, PTR_8_xi, 
    PTR_STR_8_xi, PTR_STR_xi,
    INC_sp, INC_sp_string, DEC_sp, DEC_sp_string,
    ADD_xi_offset, ADD_xi_imm,
    MOV_ax_imm, MOV_bx_imm,
    MOV_bp_sp,
    PUT_str, GET_str, GET_item, 
    FORMAT_STR, FORMAT_CHR, FORMAT_INDEX, 
    SET_file_ptr, SET_stdin, SET_stdout, FLUSH_stdin,
    RMUL, RDIV, RADD, RSUB, RNEG, RPOW,
    IMUL, IDIV, IADD, ISUB, INEG, IPOW, IMOD,
    STRCAT, 
    TEST_INDEX, TEST_NUMBER, TEST_STRING, TEST_CHAR,
    TEST_EQ, TEST_NE, TEST_GT, TEST_GE, TEST_LT, TEST_LE,
    LOGIC_OR, LOGIC_AND, LOGIC_NOT, 
    LOGIC_NOR, LOGIC_NAND, LOGIC_XOR,
    JMP, JNZ, JZ,
    CALL, RETF, CALL_stnd, RETP,
    SF_ARCCOS, SF_ARCSIN, SF_ARCTAN, SF_COS, SF_COSH,
    SP_CURSOR, SF_GETKEY,
    SF_EXP, SF_GETEXP, SF_LN, SF_LOG2, SF_LOG10,
    SF_SIN, SF_SINH, SF_SQRT,
    SF_TAN, SF_TANH,
    SF_ABS, SF_ARCTANXY,
    SF_CEIL, SF_FLOOR, SF_ROUND, SF_SIGN,
    SF_CHR, SF_CLOSE, SF_EOFF,
    SF_EREALSTR, SF_FREALSTR,
    SF_INDEX, SF_INTREAL, SF_INTSTR, SF_LENGTH, SP_LOCATE,
    SF_ORD, SF_MAX, SF_MIN, SF_OPEN, 
    SP_PUTCH, SP_PUTSTR, SP_PUTLINE, SP_PUTPIXEL,
    SF_PRED, SF_SUCC,
    SF_RAND, SF_RANDINT, SP_RANDOMIZE, SP_RANDSEED,
    SF_REALSTR, SF_REPEAT, 
    SP_SCROLL, SF_SETEXP, SP_SETVIDEO, SF_STRINT, SF_STRREAL,
    SF_VIDEOMODE, SF_VIDEOTYPE,
    SP_WATCH
}
OPCODE;

typedef struct memory_item
{
    union
    {
        struct
        {
            OPCODE  code1;
            OPCODE  code2;
            int     segment;
            int     offset;
        }
        op;

        double      real;
        long        integer;
        int         index;
        char        byte;

        struct
        {
            char    *ptr;
            int     len;
            int     sig;
        }
        string;

        struct
        {
            int     segment;
            int     offset;
            int     ax,                             // index value register
                    bx;                             // base index register
        }
        address;
   };
}
MEMORY, *MEMORY_PTR;

/*--------------------------------------------------------------------*
			 Error module
 *--------------------------------------------------------------------*/

typedef enum
{
    M_0 = 0,
    M_COMMA, M_PERIOD, M_ELLIPSES,
    M_LPAREN, M_RPAREN, M_COLON, M_ASSIGN,
    M_ARGUMENT, M_ARRAY, M_ASSIGNMENT,
    M_BY,
    M_CASE, M_CODE, M_CONSTANT, M_CONTEXT,
    M_DATA, M_DEEP, M_DIVISION, M_DO,
    M_END, M_ERROR, 
    M_FAILED, M_FIELD, M_FILE,
    M_FOR, M_FUNCTION,
    M_IDENTIFIER, M_IF, M_INCOMPATIBLE, 
    M_INTEGER, M_INVALID, M_ITEM, 
    M_LABEL, M_LABELS, M_LARGE, M_LOOP,
    M_MANY, M_MEMORY, M_MISSING,
    M_NESTING, M_NOT, M_NUMBER,
    M_OF, M_OPEN, M_OUT, M_OVERFLOW,
    M_PARAMETER, M_PARAMETERS, M_PROGRAM,
    M_RANGE, M_REAL, M_RECORD, M_REDEFINED, M_RETURN,
    M_SEGMENT, M_STACK, M_SUBSCRIPTS, M_SYNTAX,
    M_THEN, M_TOO, M_TYPE, M_TYPES,
    M_UNDEFINED, M_UNDERFLOW, M_UNION, M_USAGE,
    M_VALUE, M_VARIABLE, 
    M_WRONG,
    M_ZERO,
}   
MSG_CODE;

#ifdef DEBUG
 #define incr_sptr() if(++SPtr >= MAX_STACK_SIZE) \
		     runtime_error(M_STACK, M_OVERFLOW, M_0)
 #define decr_sptr() if(--SPtr < 0) \
		     runtime_error(M_STACK, M_UNDERFLOW, M_0)
#else
 #define incr_sptr() ++SPtr
 #define decr_sptr() --SPtr
#endif

#define int_to_real() \
	SSeg[SPtr].real = (double) SSeg[SPtr].integer

#define real_to_int() \
	SSeg[SPtr].integer = (long) SSeg[SPtr].real

/*
 *   declarations in exc_dbug.cpp
 */
void init_debugger();
void read_debugger_command();
bool execute_debugger_command(unsigned char);
void trace_statement_execution(char *, int);
void set_breakpoint();
void remove_breakpoint();
void clear_breakpoints();
void write_watch(char *);
void help();
void up_arrow();
void page_up();
void down_arrow();
void page_down();
void goto_end_of_file();
void goto_start_of_file();

int  read_key();
void goto_next_source(char*);
void goto_next_statement(int);
void load_source_file();
void write_source_line(struct line *, int);
void write_source_screen(struct line *, int);
void single_box_window(int, int, int, int, int, int);
void restore_debug_window();

/*
 *   declarations in exc_main.cpp
 */
void interpret();
void push();
void pop();
void add_xi_offset();
void put_str();
void get_str();
void get_item();
void format_str();
void format_chr();
void format_index();
void new_string();
void delete_string();
void ipow();
void str_cat();
void test();
void logic();
void debug_to_user_screen();
void user_to_debug_screen();
void write_to_user_screen(char *);
void move_up_user_screen();

/*
 *   declarations in exc_stnd.cpp
 */
void standard_routine();
void sf_close();
void sp_cursor();
void sf_eoff();
void sf_erealstr();
void sf_frealstr();
void sf_getkey();
void sf_index();
void sf_intstr();
void sp_locate();
void sf_open();
void sp_putch();
void sp_putstr();
void sp_putpixel();
void sp_putline();
void sf_realstr();
void sf_repeat();
void sp_scroll();
void sf_setexp();
void sp_setvideo();
void sf_strint();
void sf_strreal();
void sf_videomode();
void sf_videotype();
void pixel(int, int, int);

/*
 *   declarations in prs_decl.cpp
 */
void declaration();
void const_definition();
void var_declaration();
void type_definition();
void label_declaration();      

TYPE_STRUCT_PTR do_type();
TYPE_STRUCT_PTR named_type(SYMTAB_NODE_PTR);
TYPE_STRUCT_PTR string_type();
TYPE_STRUCT_PTR enumeration_type();
TYPE_STRUCT_PTR array_type();
int get_array_index(TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR record_type();
TYPE_STRUCT_PTR union_type();
void get_record_fields(TYPE_STRUCT_PTR);
void get_union_fields(TYPE_STRUCT_PTR);

void push_int_stack(int);
int pop_int_stack();

/*
 *   declarations in prs_emit.cpp
 */
void init_emit();
void exit_emit();

void init_code_segment();
void emit_code_segment(SYMTAB_NODE_PTR);
void fixup_code_buffer_addresses(int);

void emit_operator(OPCODE, OPCODE, int, int);
void emit_op_reg_imm(OPCODE, int);
void emit_index(int);
void emit_integer(long);
void emit_real(double);
void emit_string(char *);
void emit_code_label(int);
int  next_code_label();
void emit_statement_marker(char *, int);
void emit_push_imm_real(double);
void emit_push_imm_integer(long);
void emit_push_imm_index(int);
void emit_push_imm_char(char);
void emit_push_imm_string(char *);
void emit_push_address(SYMTAB_NODE_PTR);
void emit_mem_item(OPCODE, SYMTAB_NODE_PTR, TYPE_STRUCT_PTR);
void emit_var_item(OPCODE, SYMTAB_NODE_PTR, TYPE_STRUCT_PTR);
void emit_return_value(SYMTAB_NODE_PTR);
int find_offset(SYMTAB_NODE_PTR);
int find_segment(SYMTAB_NODE_PTR);

void emit_alloc_data(SYMTAB_NODE_PTR);
void emit_alloc_array(TYPE_STRUCT_PTR);
void emit_alloc_record(TYPE_STRUCT_PTR);
void emit_alloc_union(TYPE_STRUCT_PTR);

void emit_pop_local_parm(SYMTAB_NODE_PTR);
void emit_pop_formal_parm(SYMTAB_NODE_PTR);

void delete_data(SYMTAB_NODE_PTR);
void delete_array(TYPE_STRUCT_PTR);
void delete_record(TYPE_STRUCT_PTR);
void delete_union(TYPE_STRUCT_PTR);
#ifdef DEBUG
void list_segment(SYMTAB_NODE_PTR);
#endif

/*
 *   declarations in prs_expr.cpp
 */
TYPE_STRUCT_PTR string_expression();
TYPE_STRUCT_PTR boolean_expression();
TYPE_STRUCT_PTR boolean_term();
TYPE_STRUCT_PTR boolean_factor();
TYPE_STRUCT_PTR expression();
TYPE_STRUCT_PTR term();
TYPE_STRUCT_PTR factor();
TYPE_STRUCT_PTR value(SYMTAB_NODE_PTR);
TYPE_STRUCT_PTR string_subscript(TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR array_subscript_list(TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR dot_field(TYPE_STRUCT_PTR);
void get_integer_expression();
TYPE_STRUCT_PTR get_number_expression();
TYPE_STRUCT_PTR int_expression();
TYPE_STRUCT_PTR int_term();
TYPE_STRUCT_PTR int_factor();

/*
 *   declarations in prs_main.cpp
 */
void pass_one();
void pass_two();
void program_header();
void program_body();
void procedure_header();
void procedure_body();
void function_header();
void function_body();
int formal_parameters();
TYPE_STRUCT_PTR declared_routine_call(SYMTAB_NODE_PTR);
void actual_parameters(SYMTAB_NODE_PTR);
void parse_block(SYMTAB_NODE_PTR,
		  TOKEN_CODE[], TOKEN_CODE[], TOKEN_CODE[]);

/*
 *   declarations in prs_stmt.cpp
 */
void statement(SYMTAB_NODE_PTR);
void assignment_statement(SYMTAB_NODE_PTR);
TYPE_STRUCT_PTR target_variable(SYMTAB_NODE_PTR);
TYPE_STRUCT_PTR target_string_char(TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR target_array_element(TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR target_structure_field(TYPE_STRUCT_PTR);
void loop_statement(SYMTAB_NODE_PTR);
void for_statement(SYMTAB_NODE_PTR);
void if_statement(SYMTAB_NODE_PTR);
void case_statement(SYMTAB_NODE_PTR);
TYPE_STRUCT_PTR case_label();
void assert_statement();
void continue_statement();
void exit_statement();
void goto_statement();
void label_statement(SYMTAB_NODE_PTR);
void get_statement();
void put_statement();
void return_statement(SYMTAB_NODE_PTR);
void incr_level(TOKEN_CODE, int, int);
void decr_level();
bool in_for_or_loop_construct();
int for_or_loop_end_label();

/*
 *   declarations in prs_stnd.cpp
 */
TYPE_STRUCT_PTR standard_routine_call();
TYPE_STRUCT_PTR real_into_real();
TYPE_STRUCT_PTR abs_func();
TYPE_STRUCT_PTR arctanxy_func();
TYPE_STRUCT_PTR real_into_integer();
TYPE_STRUCT_PTR chr_func();
TYPE_STRUCT_PTR erealstr_func();
TYPE_STRUCT_PTR file_func();
TYPE_STRUCT_PTR frealstr_func();
TYPE_STRUCT_PTR index_func();
TYPE_STRUCT_PTR intreal_func();
TYPE_STRUCT_PTR intstr_func();
TYPE_STRUCT_PTR length_func();
TYPE_STRUCT_PTR max_min_func();
TYPE_STRUCT_PTR open_func();
TYPE_STRUCT_PTR ord_func();
TYPE_STRUCT_PTR pred_succ_func();
TYPE_STRUCT_PTR rand_func();
TYPE_STRUCT_PTR randint_func();
TYPE_STRUCT_PTR randomize_proc();
TYPE_STRUCT_PTR randseed_proc();
TYPE_STRUCT_PTR realstr_func();
TYPE_STRUCT_PTR repeat_func();
TYPE_STRUCT_PTR setexp_func();
TYPE_STRUCT_PTR string_into_number();
TYPE_STRUCT_PTR watch_proc();
TYPE_STRUCT_PTR putch_proc();
TYPE_STRUCT_PTR putstr_proc();
TYPE_STRUCT_PTR cursor_proc();
TYPE_STRUCT_PTR getkey_func();
TYPE_STRUCT_PTR locate_proc();
TYPE_STRUCT_PTR scroll_proc();
TYPE_STRUCT_PTR putline_proc();
TYPE_STRUCT_PTR putpixel_proc();
TYPE_STRUCT_PTR setvideo_proc();
TYPE_STRUCT_PTR video_func();

/*
 *   declarations in scn_main.cpp
 */
bool init_scanner(char *);
bool open_source_file(char *);
void quit_scanner();
void get_char();
void get_token();
void get_next_token();
void get_word();
bool is_key_word();
void get_number();
void get_string();
void get_character();
int  get_backslash(int);
void get_special();
bool token_in(TOKEN_CODE[]);
void synchronize(TOKEN_CODE[], TOKEN_CODE[], TOKEN_CODE[]);
bool get_source_line();
void include_file();
void delete_file();
void if_code_get_token_else_error(TOKEN_CODE);

/*
 *   declarations in sym_tabl.cpp
 */
void init_symtab();
SYMTAB_NODE_PTR lookup(char *, SYMTAB_NODE_PTR);
SYMTAB_NODE_PTR search_symbol_tables(char *);
SYMTAB_NODE_PTR insert(char *, SYMTAB_NODE_PTR *);
void incr_scope();
void decr_scope();
bool assign_type_compatible(TYPE_STRUCT_PTR, TYPE_STRUCT_PTR);
TYPE_STRUCT_PTR make_string_type_ptr(int);
TYPE_STRUCT_PTR alloc_type_struct();

/*
 *   declarations in tpl_main.cpp
 */
void init_interpreter(int, char *, char *);
void exit_interpreter();
void compile_error(MSG_CODE code, ...);
void runtime_error(MSG_CODE code, ...);
void errm_fopen();
void errm_fclose();
void save_video_mode();
void restore_video_mode();
#ifdef DEBUG
void list_fopen();
void list_fclose();
#else
 #define list_fopen()
 #define list_fclose()
#endif