PreviousUpNext

15.4.388  src/lib/compiler/back/low/tools/adl-syntax/adl-raw-syntax-junk.pkg

## adl-raw-syntax-junk.pkg

# Compiled by:
#     src/lib/compiler/back/low/tools/sml-ast.lib

stipulate
    package lem =  lowhalf_error_message;                                               # lowhalf_error_message         is from   src/lib/compiler/back/low/control/lowhalf-error-message.pkg
    package raw =  adl_raw_syntax_form;                                                 # adl_raw_syntax_form           is from   src/lib/compiler/back/low/tools/adl-syntax/adl-raw-syntax-form.pkg
herein

    package  adl_raw_syntax_junk
    : (weak) Adl_Raw_Syntax_Junk                                                        # Adl_Raw_Syntax_Junk           is from   src/lib/compiler/back/low/tools/adl-syntax/adl-raw-syntax-junk.api
    {
        fun id' path id
            =
            raw::ID_IN_EXPRESSION (raw::IDENT(path, id));

        fun id id
            =
            id' [] id;

        fun app (f, e)
            =
            raw::APPLY_EXPRESSION (id f, e);

        fun binop_exp (f, x, y)
            =
            app (f, raw::TUPLE_IN_EXPRESSION [x, y]);

        fun plus (a, raw::LITERAL_IN_EXPRESSION (raw::INT_LIT      0)) => a;
            plus (a, raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT   0u0)) => a;
            plus (a, raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT 0u0)) => a;

            plus (raw::LITERAL_IN_EXPRESSION (raw::INT_LIT      0), a) => a;
            plus (raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT   0u0), a) => a;
            plus (raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT 0u0), a) => a;

            plus (a, b) => binop_exp("+", a, b);
        end;

        fun minus (a, raw::LITERAL_IN_EXPRESSION (raw::INT_LIT     0)) => a;
            minus (a, raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT   0u0)) => a;
            minus (a, raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT 0u0)) => a;
            #
            minus (a, b) =>   binop_exp ("-", a, b);
        end;


        fun bitwise_and (a, b)
            =
            binop_exp("&&", a, b);


        fun bitwise_or (a, b)
            =
            binop_exp("||", a, b);


        fun sll (a, raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT    0u0)) => a;             # "sll" == "shift logical left" -- bitwise shift.
            sll (a, raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT  0u0)) => a;
            sll (a, raw::LITERAL_IN_EXPRESSION (raw::INT_LIT      0)) => a;
            #
            sll (a, b) =>   binop_exp("<<", a, b);
        end;

        fun slr (a, raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT   0u0)) => a;                      # "slr" == "shift logical right" -- bitwise shift shifting in zeros at high end.
            slr (a, raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT 0u0)) => a;
            slr (a, raw::LITERAL_IN_EXPRESSION (raw::INT_LIT     0)) => a;
            #   
            slr (a, b) =>   binop_exp(">>", a, b);
        end;

        fun sar (a, raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT   0u0)) => a;                      # "sar" == "shift arithmetic right" -- bitwise shift duplicating the sign bit at high end.
            sar (a, raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT 0u0)) => a;
            sar (a, raw::LITERAL_IN_EXPRESSION (raw::INT_LIT     0)) => a;
            #
            sar (a, b) =>   binop_exp(">>>", a, b);
        end;

        fun bool_exp x = raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT x);

        fun string_constant_in_expression    s =  raw::LITERAL_IN_EXPRESSION (raw::STRING_LIT  s);
        fun integer_constant_in_expression   x =  raw::LITERAL_IN_EXPRESSION (raw::INT_LIT     x);
        #
        fun int1expression                  x =  raw::LITERAL_IN_EXPRESSION (raw::INT1_LIT   x);
        fun integerexp                        x =  raw::LITERAL_IN_EXPRESSION (raw::INTEGER_LIT x);
        #
        fun character_constant_in_expression x =  raw::LITERAL_IN_EXPRESSION (raw::CHAR_LIT    x);
        #
        fun unt_constant_in_expression       x =  raw::LITERAL_IN_EXPRESSION (raw::UNT_LIT     x);
        fun unt1expression                  x =  raw::LITERAL_IN_EXPRESSION (raw::UNT1_LIT   x);
        #
        fun bool_pat                         x =  raw::LITPAT (raw::BOOL_LIT    x);
        fun string_constant_in_pattern       s =  raw::LITPAT (raw::STRING_LIT  s);
        #
        fun integer_constant_in_pattern      x =  raw::LITPAT (raw::INT_LIT     x);
        fun int1pattern                     x =  raw::LITPAT (raw::INT1_LIT   x);
        fun integerpat                        x =  raw::LITPAT (raw::INTEGER_LIT x);
        #
        fun character_constant_in_pattern    x =  raw::LITPAT (raw::CHAR_LIT    x);
        fun unt_constant_in_pattern          x =  raw::LITPAT (raw::UNT_LIT     x);
        fun unt1pattern                     x =  raw::LITPAT (raw::UNT1_LIT   x);

        void =  raw::TUPLE_IN_EXPRESSION [];

        true  =  bool_exp  TRUE;
        false =  bool_exp  FALSE;

        fun and_fn (raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT TRUE),  x) =>  x;
            and_fn (raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT FALSE), x) =>  false;
            #
            and_fn (x, raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT TRUE )) =>  x;
            and_fn (x, raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT FALSE)) =>  false;
            #
            and_fn (x, y) => binop_exp("andalso", x, y);
        end;

        fun or_fn (raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT TRUE ), x) =>  true;
            or_fn (raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT FALSE), x) =>  x;
            #
            or_fn (x, raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT TRUE )) =>  true;
            or_fn (x, raw::LITERAL_IN_EXPRESSION (raw::BOOL_LIT FALSE)) =>  x;
            #
            or_fn (x, y) => binop_exp("or", x, y);
        end;

        nil_exp =  raw::LIST_IN_EXPRESSION ([], NULL);


        void_type     =  raw::IDTY (raw::IDENT([], "Void"));
        bool_type     =  raw::IDTY (raw::IDENT([], "Bool"));
        int_type      =  raw::IDTY (raw::IDENT([], "Int"));
        register_type =  raw::IDTY (raw::IDENT(["rkj"], "Codetemp_Info"));

        register_list_type =  raw::APPTY (raw::IDENT([], "List"), [register_type]);
        int_list_type      =  raw::APPTY (raw::IDENT([], "List"), [int_type]);

        string_type =  raw::IDTY (raw::IDENT([],        "String"));
        unt1_type   =  raw::IDTY (raw::IDENT(["one_word_unt"], "Unt"));
        unt_type    =  raw::IDTY (raw::IDENT(["unt"],   "Unt"));
        label_type  =  raw::IDTY (raw::IDENT(["label"], "Label"));

        label_expression_type =  raw::IDTY (raw::IDENT (["label_expression"], "Label_Expression"));

        constant_type  =  raw::IDTY (raw::IDENT(["constant"], "Const"));
        cell_kind_type =  raw::IDTY (raw::IDENT(["rkj"], "Registerkind"));
        cell_set_type  =  raw::IDTY (raw::IDENT([], "Codetemplists"));

        fun sumtypefun (name, args, cbs)
            = 
            raw::SUMTYPE { name, typevars=>args, mc=>NULL, asm=>FALSE, field'=>NULL, cbs };

        fun cons (name, arg)
            =
            raw::CONSTRUCTOR
              { name, type=>arg, mc=>NULL, asm=>NULL, rtl=>NULL,
                nop=>raw::FLAGOFF, nullified=>raw::FLAGOFF,
                delayslot=>NULL,
                delayslot_candidate=>NULL, sdi=>NULL, latency=>NULL,
                pipeline=>NULL, loc=>line_number_database::dummy_loc
              };

        fun my_fn (id, e)
            =
            raw::VAL_DECL
              [ raw::NAMED_VARIABLE
                  (
                    case id   "_" =>  raw::WILDCARD_PATTERN;
                               _  =>  raw::IDPAT id;
                    esac,
                    e
                  )
              ];

        fun fun_fn'(id, p, e) =  raw::FUN (id, [raw::CLAUSE([p], NULL, e)]);
        fun fun_fn (id, p, e) =  raw::FUN_DECL [fun_fn'(id, p, e)];

        fun let_fn ([], e) =>  e; 
            let_fn ( d, e) =>  raw::LET_EXPRESSION (d,[e]);
        end;


        fun error_fn  text
            =
            raw::CLAUSE ([raw::WILDCARD_PATTERN], NULL, app("error", string_constant_in_expression text));

        fun error_fun_fn  name
            = 
            raw::VERBATIM_CODE
              [ "fun error msg",
                "    =",
                "    lem::error (\"" + name + "\", msg);"
              ];

        fun dummy_fun  name
            = 
            raw::VERBATIM_CODE ["fun " + name + " _ = error \"" + name + "\";"];


        fun bitslice (e, ranges)
            =
            {   temp = id "temp";

                fun gen (tmp, [], pos, e)
                        =>
                        e;

                    gen (tmp, (a, b) ! slices, pos, e)
                        =>
                        {   width = b - a + 1;
                            mask  = one_word_unt::(<<) (0u1, unt::from_int width) - 0u1;

                            field' = sll (tmp, unt1expression (one_word_unt::from_int a));
                            field' = bitwise_and (field', unt1expression mask);

                            gen (tmp, slices, pos+width,
                                plus (sll (field', unt1expression (one_word_unt::from_int pos)), e));
                        };
                end;

                fun emit (tmp)
                    =
                    gen (tmp, reverse ranges, 0, unt1expression 0u0);

                case ranges
                    #
                    [_] =>  emit e;
                    _   =>  raw::LET_EXPRESSION( [raw::VAL_DECL [raw::NAMED_VARIABLE (raw::IDPAT "temp", e)]],
                                                 [emit (id "temp")]
                                               );
                esac;
            };

        # Add an entry:
        #
        fun cons' (x, raw::LIST_IN_EXPRESSION (a, b)) =>  raw::LIST_IN_EXPRESSION  (x ! a, b);
            cons' (x, y)                   =>  raw::LIST_IN_EXPRESSION ([x], THE y);
        end;

        # Append an entry:
        #
        fun append (x, raw::LIST_IN_EXPRESSION([], NULL)) =>   x;
            append (x, y)                      =>   app("@", raw::TUPLE_IN_EXPRESSION [x, y]);
        end;

        fun compare_literal (x, y)
            =
            {   fun kind (raw::INT_LIT     _) =>  0;
                    kind (raw::BOOL_LIT    _) =>  1;
                    kind (raw::STRING_LIT  _) =>  2;
                    kind (raw::CHAR_LIT    _) =>  3;
                    kind (raw::UNT_LIT     _) =>  4;
                    kind (raw::UNT1_LIT   _) =>  5;
                    kind (raw::INTEGER_LIT _) =>  6;
                    kind (raw::FLOAT_LIT   _) =>  7;
                    kind (raw::INT1_LIT   _) =>  8;
                end;

                case (x, y)
                    #
                    (raw::INT_LIT     x, raw::INT_LIT     y) =>  int::compare     (x, y);
                    (raw::INT1_LIT   x, raw::INT1_LIT   y) =>  one_word_int::compare   (x, y);
                    (raw::STRING_LIT  x, raw::STRING_LIT  y) =>  string::compare  (x, y);
                    (raw::CHAR_LIT    x, raw::CHAR_LIT    y) =>  char::compare    (x, y);
                    (raw::UNT_LIT     x, raw::UNT_LIT     y) =>  unt::compare     (x, y);
                    (raw::UNT1_LIT   x, raw::UNT1_LIT   y) =>  one_word_unt::compare   (x, y);
                    (raw::INTEGER_LIT x, raw::INTEGER_LIT y) =>  multiword_int::compare (x, y);
                    (raw::FLOAT_LIT   x, raw::FLOAT_LIT   y) =>  string::compare  (x, y);
                    (raw::BOOL_LIT    x, raw::BOOL_LIT    y) =>  if   (x == y     )   EQUAL; 
                                                                 elif (x == FALSE )   LESS;
                                                                 else                 GREATER;
                                                                 fi;

                    (x, y)                         =>  int::compare (kind x, kind y);
                esac;
            };
    };                                                                                          # package  adl_raw_syntax_junk
end;                                                                                            # stipulate


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext