15.3.162  src/lib/compiler/back/low/tools/adl-syntax/adl-raw-syntax-junk.api

# adl-raw-syntax-junk.api

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


stipulate
    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

    # This api is implemented in:
    #     src/lib/compiler/back/low/tools/adl-syntax/adl-raw-syntax-junk.pkg
    #
    api  Adl_Raw_Syntax_Junk {
        #

        # Abbreviations:
        #
        id':   List(String) -> String -> raw::Expression;                       # For an identifier         xyz::foo
        id:                    String -> raw::Expression;                       # For a simple identifier   foo      -- this is identical to   id' [] "foo"
        #
        app:      (String, raw::Expression) -> raw::Expression;
        plus:     (raw::Expression, raw::Expression) -> raw::Expression;
        minus:    (raw::Expression, raw::Expression) -> raw::Expression;
        bitwise_and:     (raw::Expression, raw::Expression) -> raw::Expression;
        bitwise_or:      (raw::Expression, raw::Expression) -> raw::Expression;
        sll:      (raw::Expression, raw::Expression) -> raw::Expression;        # "sll" may be "shift logical left"
        slr:      (raw::Expression, raw::Expression) -> raw::Expression;        # "slr" may be "shift logical right"
        sar:      (raw::Expression, raw::Expression) -> raw::Expression;        # "sar" may be "shift arithmetic right"
        false:    raw::Expression;
        true:     raw::Expression;
        and_fn:   (raw::Expression, raw::Expression) -> raw::Expression;
        or_fn:    (raw::Expression, raw::Expression) -> raw::Expression;
        void:     raw::Expression;
        nil_exp:  raw::Expression;

        integer_constant_in_expression:        Int -> raw::Expression;
        int1expression:         one_word_int::Int -> raw::Expression;
        integerexp:                    multiword_int::Int -> raw::Expression;
        #
        unt_constant_in_expression:            Unt -> raw::Expression;
        unt1expression:                one_word_unt::Unt -> raw::Expression;
        #
        string_constant_in_expression:      String -> raw::Expression;
        character_constant_in_expression:     Char -> raw::Expression;
        bool_exp:                             Bool -> raw::Expression;

        integer_constant_in_pattern:           Int -> raw::Pattern;
        int1pattern:                   one_word_int::Int -> raw::Pattern;
        integerpat:                    multiword_int::Int -> raw::Pattern;
        #
        unt_constant_in_pattern:               Unt -> raw::Pattern;
        unt1pattern:                   one_word_unt::Unt -> raw::Pattern;
        #
        string_constant_in_pattern:         String -> raw::Pattern;
        character_constant_in_pattern:        Char -> raw::Pattern;
        bool_pat:                             Bool -> raw::Pattern;

        void_type:              raw::Type;
        bool_type:              raw::Type;
        int_type:               raw::Type;
        register_type:          raw::Type;
        register_list_type:     raw::Type;
        int_list_type:          raw::Type;
        string_type:            raw::Type;
        unt1_type:              raw::Type;
        unt_type:               raw::Type;
        label_type:             raw::Type;
        label_expression_type:  raw::Type;
        constant_type:          raw::Type;
        cell_kind_type:         raw::Type;
        cell_set_type:          raw::Type;

        sumtypefun:  (raw::Id, List( raw::Typevar_Ref ), List( raw::Constructor ))
            -> raw::Sumtype;
        cons:    (raw::Id, Null_Or( raw::Type )) -> raw::Constructor;
        my_fn:   (raw::Id, raw::Expression) -> raw::Declaration; 
        fun_fn:  (raw::Id, raw::Pattern, raw::Expression) -> raw::Declaration;
        fun_fn': (raw::Id, raw::Pattern, raw::Expression) -> raw::Fun;
        let_fn:  (List( raw::Declaration ), raw::Expression) -> raw::Expression;

        error_fn:      String -> raw::Clause;
        error_fun_fn:  String -> raw::Declaration;
        dummy_fun:     String -> raw::Declaration;

        cons':  (raw::Expression, raw::Expression) -> raw::Expression;
        append:  (raw::Expression, raw::Expression) -> raw::Expression;

        # Generate an expression that computes a bitslice:
        #
        bitslice:  (raw::Expression, List( raw::Range )) -> raw::Expression;

        compare_literal:  (raw::Literal, raw::Literal) -> Order;
    };
end;