15.4.295  src/lib/compiler/back/low/main/nextcode/client-pseudo-ops-mythryl-g.pkg

## client-pseudo-ops-mythryl-g.pkg -- pseudo ops

# Compiled by:
#     src/lib/compiler/core.sublib

# We are invoked from:
#
#     src/lib/compiler/back/low/main/pwrpc32/backend-lowhalf-pwrpc32.pkg
#     src/lib/compiler/back/low/main/sparc32/backend-lowhalf-sparc32.pkg
#     src/lib/compiler/back/low/main/intel32/backend-lowhalf-intel32-g.pkg

stipulate
    package lbl =  codelabel;                                           # codelabel                     is from   src/lib/compiler/back/low/code/codelabel.pkg
    package pbt =  pseudo_op_basis_type;                                # pseudo_op_basis_type          is from   src/lib/compiler/back/low/mcg/pseudo-op-basis-type.pkg
herein

    generic package   client_pseudo_ops_mythryl_g   (
        #             ===========================
        #
        package bpo: Base_Pseudo_Ops;                                   # Base_Pseudo_Ops               is from   src/lib/compiler/back/low/mcg/base-pseudo-ops.api
    )
    : (weak) Client_Pseudo_Ops_Mythryl                                  # Client_Pseudo_Ops_Mythryl     is from   src/lib/compiler/back/low/main/nextcode/client-pseudo-ops-mythryl.api
    {
        # Export to client packages:
        #
        package bpo =  bpo;                                             # "bpo" == "base_pseudo_ops".   

        stipulate
            package tcf =  bpo::tcf;                                    # "tcf" == "treecode_form".
        herein

            Lib7_Pseudo_Op
              #
              = FILENAME  String
              #
              | JUMPTABLE { base:           lbl::Codelabel,
                            targets:  List( lbl::Codelabel )
                          }
              ;

            Pseudo_Op
                 =
                 Lib7_Pseudo_Op;

            fun to_basis (JUMPTABLE { base, targets } )
                    =>
                    {   fun target_offset label
                            =
                            tcf::SUB (32, tcf::LABEL label, tcf::LABEL base);

                        fun pseudo_op_off label
                            =
                            pbt::INT { size=>32, i => [tcf::LABEL_EXPRESSION (target_offset label)] };

                        pbt::ALIGN_SIZE 2 !
                           pbt::DATA_LABEL base !
                             list::fold_backward
                                 (fn (target, acc) = pseudo_op_off target ! acc)
                                 []
                                 targets;
                    };

                to_basis (FILENAME file)
                    =>
                    {   fun int_8 n
                            =
                            pbt::INT { size=>8, i=> [tcf::LITERAL (tcf::mi::from_int (8, n))] };

                        # Adjust for zero termination and
                        # last byte containing the length: 
                        #
                        len =   unt::from_int (string::length file) + 0u2;

                        k4  =   unt::bitwise_and (len + 0u3, unt::bitwise_not 0u3);

                        fun pad 0u0 =>   [int_8 (unt::to_int (unt::(>>) (k4, 0u2)))];
                            pad n   =>    int_8 (0) ! pad (n - 0u1);
                        end;

                        pbt::ALIGN_SIZE 2 ! pbt::ASCIIZ(file) ! pad (k4-len); 
                    };
            end;

            fun pseudo_op_to_string  pseudo_op
                = 
                string::cat(
                  list::fold_backward 
                    (fn (p, acc) =  bpo::pseudo_op_to_string p + "\n" ! acc) 
                    []
                    (to_basis  pseudo_op)
                );

            fun put_pseudo_op { pseudo_op, loc, put_byte }
                =
                {   pb =   to_basis pseudo_op;

                    list::fold_forward  put_pseudo_op'  loc  (to_basis pseudo_op)
                    where
                        fun put_pseudo_op' (pseudo_op, loc)
                            = 
                            {   bpo::put_pseudo_op { pseudo_op, loc, put_byte };
                                #
                                loc + bpo::current_pseudo_op_size_in_bytes (pseudo_op, loc);
                            };
                    end;

                    ();
                };

            fun current_pseudo_op_size_in_bytes (pseudo_op, loc)
                = 
                list::fold_forward 
                    (fn (pseudo_op, result_so_far) =   result_so_far   +   bpo::current_pseudo_op_size_in_bytes (pseudo_op, loc)) 
                    0
                    (to_basis pseudo_op);

            fun adjust_labels (JUMPTABLE { base, ... }, loc)
                    =>
                    {   base_addr
                            =
                            loc   +   bpo::current_pseudo_op_size_in_bytes (pbt::ALIGN_SIZE 2, loc);

                        if (lbl::get_codelabel_address base == base_addr)
                            #
                            FALSE;
                        else
                            lbl::set_codelabel_address (base, base_addr);
                            TRUE;
                        fi;
                    };

                adjust_labels (FILENAME _, _)
                    =>
                    FALSE;
            end;
        end;
    };
end;


## COPYRIGHT (c) 2001 AT&T Bell Laboratories.
## Subsequent changes by Jeff Prothero Copyright (c) 2010-2013,
## released per terms of SMLNJ-COPYRIGHT.