/home/archives/ucsd-psystem-xc/branch.0/branch.0/delta27403.167/lib/translator.h

Go to the documentation of this file.

//
// UCSD p-System cross compiler
// Copyright (C) 2006 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at
// you option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
// USA
//

#ifndef LIB_TRANSLATOR_H
#define LIB_TRANSLATOR_H

#include <lib/scope.h>
#include <lib/scope/stack.h>
#include <lib/expression/dispatcher/binary.h>
#include <lib/expression/dispatcher/unary.h>
#include <lib/expression/smart_pointer.h>
#include <lib/label/smart_pointer.h>
#include <lib/statement/smart_pointer.h>
#include <lib/type.h>

class expression_list; // forward
class name_type_list; // forward
class rcstring; // forward
class statement_list; // forward
class symbol; // forward
class symbol_function; // forward
class type_enumerated; // forward
class variable_name; // forward
class variable_name_list; // forward

class translator
{
public:
    virtual ~translator();

    translator();

    void parse(const rcstring &filename);

    void define_builtin_symbols();

    expression::pointer sizeof_expression(
        const expression::pointer &arg);

    type::pointer new_array_type(bool packed, const type::pointer &index_type,
        const type::pointer &subtype);

    expression::pointer sizeof_expression(const type::pointer &arg);

protected:
    virtual expression::pointer sizeof_expression_factory(
        const expression::pointer &arg);

    virtual expression::pointer sizeof_expression_factory(
        const type::pointer &arg) = 0;

public:
    scope::pointer program_scope(const rcstring &name);

protected:
    virtual scope::pointer program_scope_factory(const rcstring &name) = 0;

    virtual symbol *function_symbol_factory(const rcstring &name,
        const scope::pointer &scp, int lex_level) = 0;

public:
    scope::pointer function_scope(const rcstring &name, bool is_func,
        bool new_seg);

protected:
    virtual scope::pointer function_scope_factory(const rcstring &name,
        bool is_func, bool new_seg) = 0;

public:
    void scope_attach_return_type(const type::pointer &tp);

    bool current_function_definition_was_forward() const;

    void scope_to_be_continued();

    void scope_end();

    void scope_attach_function_arguments(name_type_list *ntlp);

    void constant_declaration(const variable_name &name,
        const expression::pointer &ep);

    void type_declaration(const variable_name &name,
        const type::pointer &tp);

    type::pointer type_lookup(const rcstring &name, bool deferable);

    type::pointer string_type(const expression::pointer &size);

    void variable_declaration(const variable_name_list &names,
        const type::pointer &tsp);

    void scope_attach_body(const statement::pointer &sp);

    virtual statement::pointer compound_statement_factory(
        statement_list *arg);

public:
    statement::pointer expression_statement(
        const expression::pointer &arg);

protected:
    virtual statement::pointer expression_statement_factory(
        const expression::pointer &arg);

public:
    statement::pointer if_statement(
        const expression::pointer &condition,
        const statement::pointer &then_clause,
        const statement::pointer &else_clause);

protected:
    virtual statement::pointer if_statement_factory(
        const expression::pointer &condition,
        const statement::pointer &then_clause,
        const statement::pointer &else_clause) = 0;

public:
    statement::pointer while_statement(
        const expression::pointer &condition,
        const statement::pointer &body);

protected:
    virtual statement::pointer while_statement_factory(
        const expression::pointer &condition,
        const statement::pointer &body) = 0;

public:
    statement::pointer until_statement(const statement::pointer &body,
        const expression::pointer &condition);

protected:
    virtual statement::pointer until_statement_factory(
        const statement::pointer &body,
        const expression::pointer &condition) = 0;

    virtual statement::pointer infinite_loop_factory(
        const statement::pointer &body) = 0;

public:
    virtual statement::pointer empty_statement_factory();

    virtual statement::pointer writeln_statement(expression_list *arg);

protected:
    virtual statement::pointer writeln_statement_factory(
        expression_list *arg) = 0;

public:
    expression::pointer function_call_expression(
        expression::pointer fname, expression_list *elp);

    expression::pointer name_expression(const rcstring &name);

protected:
    virtual expression::pointer name_expression_factory(symbol *sp) = 0;

public:
    expression::pointer logical_and_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer logical_and_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer logical_or_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer logical_or_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer addition_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer integer_plus_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_plus_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_plus_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_plus_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer set_union_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer subtraction_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer integer_minus_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_minus_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_minus_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_minus_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer set_difference_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer multiplication_expression(
        const expression::pointer &lhs, const expression::pointer &rhs);

protected:
    virtual expression::pointer integer_times_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_times_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_times_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_times_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer set_intersection_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer integer_division_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer integer_div_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer real_division_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    expression::pointer integer_over_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    expression::pointer integer_over_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    expression::pointer real_over_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    virtual expression::pointer real_over_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer ge_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_ge_boolean_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer enum_ge_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_ge_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_ge_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_ge_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_ge_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer string_ge_string_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer gt_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_gt_boolean_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer enum_gt_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_gt_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_gt_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_gt_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_gt_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer string_gt_string_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer le_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_le_boolean_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer enum_le_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_le_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_le_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_le_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_le_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer string_le_string_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer lt_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_lt_boolean_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer enum_lt_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_lt_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    expression::pointer integer_lt_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    expression::pointer real_lt_integer_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer real_lt_real_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

    virtual expression::pointer string_lt_string_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs) = 0;

public:
    expression::pointer eq_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_eq_boolean_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    expression::pointer enum_eq_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_eq_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    expression::pointer integer_eq_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    expression::pointer real_eq_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    virtual expression::pointer real_eq_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    virtual expression::pointer string_eq_string_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer ne_expression(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

protected:
    virtual expression::pointer boolean_ne_boolean_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    expression::pointer enum_ne_enum_expression_factory(
        const expression::pointer &lhs, const expression::pointer &rhs);

    virtual expression::pointer integer_ne_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    expression::pointer integer_ne_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    expression::pointer real_ne_integer_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    virtual expression::pointer real_ne_real_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

    virtual expression::pointer string_ne_string_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs) = 0;

public:
    expression::pointer dereference_expression(
        const expression::pointer &arg);

protected:
    virtual expression::pointer dereference_expression_factory(
        const expression::pointer &arg) = 0;

public:
    virtual expression::pointer boolean_expression_factory(bool value) = 0;

    virtual expression::pointer integer_expression_factory(
        const rcstring &value) = 0;

    expression::pointer negate_expression(const expression::pointer &arg);

protected:
    virtual expression::pointer integer_negate_expression_factory(
        const expression::pointer &arg) = 0;

    virtual expression::pointer real_negate_expression_factory(
        const expression::pointer &arg) = 0;

public:
    expression::pointer logical_not_expression(
        const expression::pointer &arg);

protected:
    virtual expression::pointer logical_not_expression_factory(
        const expression::pointer &arg) = 0;

public:
    expression::pointer empty_set_expression();

protected:
    virtual expression::pointer empty_set_expression_factory(
        const location &locn, const type::pointer &tp) = 0;

public:
    expression::pointer set_expression(const expression::pointer &lo,
        const expression::pointer &hi);

    expression::pointer set_expression(const expression::pointer &singleton);

protected:
    virtual expression::pointer set_expression_factory(
        const expression::pointer &lo, const expression::pointer &hi) = 0;

    virtual expression::pointer set_expression_factory(
        const expression::pointer &singleton) = 0;

public:
    virtual expression::pointer char_expression_factory(const location &locn,
        unsigned char value) = 0;

    virtual expression::pointer real_expression_factory(
        const rcstring &value) = 0;

    virtual expression::pointer string_expression_factory(
        const rcstring &value) = 0;

    void traversal();

    void enable_grammar_debug();

public:
    expression::pointer dereference_if_necessary(
        const expression::pointer &arg);

    expression::pointer assignment_expression_factory(
        const expression::pointer &lhs,
        const expression::pointer &rhs);

    virtual expression::pointer real_from_integer_expression_factory(
        const expression::pointer &arg) = 0;

    expression::pointer dot_expression(const expression::pointer &lhs,
        const variable_name &rhs);

    expression::pointer array_index_expression(const expression::pointer &lhs,
        const expression::pointer &rhs);

    type::pointer subrange_type(const expression::pointer &minimum,
        const expression::pointer &maximum);

    type::pointer set_type(const type::pointer &subtype);

protected:
    virtual void pre_order_traversal();

    virtual void post_order_traversal();

public:
    bool is_current_function(symbol *sp) const;

    virtual label::pointer label_factory();

    int get_lex_level() const;

    bool is_a_sysprog() const { return syscomp; }

    void comment(const rcstring &text);

protected:
    virtual void comment_notify(const rcstring &text);

    void interpret_comment(const rcstring &text);

    virtual void codefile_bigendian();

    virtual void codefile_copyright(const rcstring &text);

    virtual void codefile_library(const rcstring &filename);

protected:
    virtual expression::pointer set2set_expression_factory(
        const type::pointer &to, const expression::pointer &from) = 0;

    virtual symbol *builtin_chr_factory() = 0;

    virtual symbol *builtin_dec_factory() = 0;

    virtual symbol *builtin_inc_factory() = 0;

    virtual symbol *builtin_odd_factory() = 0;

    virtual symbol *builtin_ord_factory() = 0;

    virtual symbol *builtin_pred_factory() = 0;

    virtual symbol *builtin_sqr_factory() = 0;

    virtual symbol *builtin_succ_factory() = 0;

    virtual symbol *builtin_time_factory() = 0;

    virtual symbol_function *builtin_syscall_factory(const rcstring &name,
        int proc_num) = 0;

public:
    bit_address get_data_mark() const;

    void set_data_mark(const bit_address &arg);

    bool issue_iocheck() const { return iocheck; }

    bool issue_breakpoint() const { return breakpoints_flag; }

    bool issue_range_check() const { return range_check; }

    type::pointer record_begin(bool is_packed);

    void record_member(variable_name_list &name, type::pointer &tp);

    void record_end();

    void with_begin(const expression::pointer &var);

    void with_end();

    bool is_a_type_name(const rcstring &name) const;

    type::pointer enumerated_begin();

    void enumerated_tag(const variable_name &name);

    void enumerated_end();

private:
    bool debug;

    scope_stack scopes;

    scope::pointer builtins;

    bool syscomp;

    bool no_more_codefile_options;

    bool iocheck;

    bool breakpoints_flag;

    bool goto_ok;

    bool range_check;

    type::pointer current_enum;
    type_enumerated *current_enum_raw;

    expression_dispatcher_binary op_addition;

    expression_dispatcher_binary op_subtraction;

    expression_dispatcher_binary op_multiplication;

    expression_dispatcher_binary op_div;

    expression_dispatcher_binary op_division;

    expression_dispatcher_binary op_eq;

    expression_dispatcher_binary op_ne;

    expression_dispatcher_binary op_lt;

    expression_dispatcher_binary op_le;

    expression_dispatcher_binary op_gt;

    expression_dispatcher_binary op_ge;

    expression_dispatcher_unary op_negate;

    translator(const translator &);

    translator &operator=(const translator &);
};

#endif // LIB_TRANSLATOR_H

---