PreviousUpNext

15.4.663  src/lib/compiler/front/typer/print/print-as-nada-junk.pkg

## print-as-nada-junk.pkg 

# Compiled by:
#     src/lib/compiler/front/typer/typer.sublib

package   print_as_nada_junk
: (weak)  Print_As_Nada_Junk            # Print_As_Nada_Junk    is from   src/lib/compiler/front/typer/print/print-as-nada-junk.api
{
    package s: (weak)  Symbol           # Symbol        is from   src/lib/compiler/front/basics/map/symbol.api
             =  symbol;                 # symbol        is from   src/lib/compiler/front/basics/map/symbol.pkg

    package pp= prettyprint;            # prettyprint   is from   src/lib/prettyprint/big/src/prettyprint.pkg
    package ip= inverse_path;           # inverse_path  is from   src/lib/compiler/front/typer-stuff/basics/symbol-path.pkg
    package sp= symbol_path;            # symbol_path   is from   src/lib/compiler/front/typer-stuff/basics/symbol-path.pkg

    pps = pp::string;

    fun print_sequence0_as_nada ppstream (sep: pp::Stream -> Void, pr, elems)
        =
        { fun pr_elems [el] => pr ppstream el;
               pr_elems (el ! rest) =>
                  { pr ppstream el;
                   sep ppstream;
                   pr_elems rest;};
               pr_elems [] => (); end;
        
            pr_elems elems;
        };

     Break_Style
        =
        CONSISTENT | INCONSISTENT;

    fun open_style_box style
        = 
        case style
            CONSISTENT   => pp::begin_indented_horizontal_else_vertical_box;
            INCONSISTENT => pp::begin_indented_wrap_box;
        esac;

    fun print_sequence_as_nada
            ppstream
            {   sep:   pp::Stream -> Void,
                pr:    pp::Stream -> X -> Void, 
                style: Break_Style
            }
            (elems: List(X))
        =
        {   open_style_box style ppstream (pp::CURSOR_RELATIVE 0);
            print_sequence0_as_nada ppstream (sep, pr, elems);
            pp::end_box ppstream
        ;};

    fun print_closed_sequence_as_nada
            ppstream
            {   front: pp::Stream -> Void,
                sep:   pp::Stream -> Void,
                back:  pp::Stream -> Void,
                pr:    pp::Stream -> X -> Void,
                style: Break_Style
            }
            (elems: List(X))
        =
        {   pp::begin_horizontal_else_vertical_box ppstream;
            front ppstream;
            open_style_box style ppstream (pp::CURSOR_RELATIVE 0);
            print_sequence0_as_nada ppstream (sep, pr, elems); 
            pp::end_box ppstream;
            back ppstream;
            pp::end_box ppstream
        ;};

    fun print_symbol_as_nada ppstream (s: s::Symbol)
        =
        pp::string ppstream (s::name s);

    string_depth = control_print::string_depth;

    heap_string = print_junk::heap_string;

    fun print_lib7_string_as_nada  ppstream   =   pp::string ppstream o print_junk::print_heap_string;
    fun print_integer_as_nada    ppstream   =   pp::string ppstream o print_junk::print_integer;

    fun ppvseq ppstream ind (separator: String) pr elements
        =
        { fun print_elements [element]   =>   pr ppstream element;

               print_elements (element ! rest) => {   pr ppstream element; 
                                                    pp::string ppstream separator; 
                                                    pp::newline ppstream;
                                                    print_elements rest
                                                ;};
               print_elements []   =>   (); end;
        
            pp::begin_indented_horizontal_else_vertical_box ppstream (pp::CURSOR_RELATIVE ind);
            print_elements elements;
            pp::end_box ppstream;
        };

    fun ppvlist stream (header, separator, print_item, items)
        =
        case items

             NIL   =>   ();

            first ! rest
             =>
             {   pp::string stream header;
                 print_item stream first;

                 apply (fn x => {   pp::newline stream;
                                  pp::string stream separator;
                                  print_item stream x
                              ;}; end 
                     )
                     rest
             ;}; esac;

    fun ppvlist' stream (header, separator, print_item, items)
        =
        case items

             NIL => ();

            first ! rest
             =>
             {   print_item stream header first;

                 apply (fn x => {   pp::newline stream;
                                  print_item stream separator x
                              ;}; end 
                     )
                     rest
             ;}; esac;

    #  Debug print functions 

    fun print_int_path_as_nada ppstream
        =
        print_closed_sequence_as_nada
            ppstream 
            {   front => (fn pps => pp::string pps "["; end ),
                sep   => (fn pps => { pp::string pps ", "; pp::break pps { spaces=>0, indent_on_wrap=>0 } ;}; end ),
                back  => (fn pps => pp::string pps "]"; end ),
                style => INCONSISTENT,
                pr    => (fn pps => pp::string pps o int::to_string; end )
            };

    fun print_symbol_path_as_nada ppstream (sp: symbol_path::Symbol_Path)
        = 
        pp::string ppstream (symbol_path::to_string sp);

    fun print_inverse_path_as_nada ppstream (inverse_path::INVERSE_PATH path: inverse_path::Inverse_Path)
        =
        print_closed_sequence_as_nada
            ppstream 
            {   front => (fn pps => pp::string pps "<"; end ),
                sep   => (fn pps => (pp::string pps "."); end ),
                back  => (fn pps => pp::string pps ">"; end ),
                style => INCONSISTENT,
                pr    => print_symbol_as_nada
            }
            path;


    # find_path:  Convert inverse symbolic path names
    #              to a printable string in the context
    #              of a dictionary.
    #
    #  Its arguments are the inverse symbolic path, a check predicate on static
    #  semantic values, and a lookup function mapping paths to their namings
    #  (if any) in an dictionary and raising Dictionary::UNBOUND on paths with no
    #  naming.
    #
    #  It looks up each suffix of the path name, going from shortest to longest
    #  suffix, in the current dictionary until it finds one whose lookup value
    #  satisfies the check predicate.  It then converts that suffix to a string.
    #  If it doesn't find any suffix, the full path (reversed, i.e. in the 
    #  normal order) and the boolean value FALSE are returned, otherwise the
    #  suffix and TRUE are returned.
    #
    #  Example:
    #        Given a::B.t as a path, and a lookup function for an
    #        dictionary, this function tries:
    #                  t
    #                  b::t
    #                  a::B.t
    #        If none of these work, it returns ?.a::B.t
    #
    #  Note: the symbolic path is passed in reverse order because that is
    #  the way all symbolic path names are stored within static semantic chunks.


    result_id = s::make_package_symbol "<result_package>";
    return_id = s::make_package_symbol "<return_package>";

    fun find_path (ip::INVERSE_PATH p: ip::Inverse_Path, check, get): ((List( s::Symbol ), Bool))
        =
        { fun try (name ! untried, tried)
                =>
                (   if   ((s::eq (name, result_id))   or   (s::eq (name, return_id))) 
                        
                         try (untried, tried);
                    else
                         { element   =   get (sp::SYMBOL_PATH (name ! tried));
                         
                             if    (check element)
                                  (name ! tried, TRUE);
                             else try (untried, name ! tried);fi;
                         }
                         except
                             symbolmapstack::UNBOUND
                             =>
                             try (untried, name ! tried); end ;fi
                );

               try([], tried) => (tried, FALSE); end;
        
            try (p, []);
        };


    fun print_int_as_nada stream (i: Int)
        =
        pps stream (int::to_string i);

    fun print_comma_as_nada stream
        =
        pps stream ", ";

    fun print_comma_newline_as_nada stream
        =
        {   print_comma_as_nada stream;
            pp::newline stream
        ;};

    fun newline_indent stream i
        =
        { linewidth = 10000;
        
            pp::break stream { spaces => linewidth,   indent_on_wrap => i };
        };

    fun newline_apply stream f
        =
        { fun g []                =>   ();
               g [element]         =>   f stream element;
               g (element ! rest)   =>  { f stream element; pp::newline stream; g rest;}; end;
        
            g;
        };

    fun break_apply stream f
        =
        { fun g []         =>  ();
               g [el]       =>  f stream el;
               g (el ! rst)  =>  { f stream el; pp::break stream { spaces=>1, indent_on_wrap=>0 }; g rst;}; end;
        
            g;
        };

    fun en_pp stream           #  "en" for ... "enclose" ...? 
        =
        {   begin_horizontal_else_vertical_box  => (fn indent => pp::begin_indented_horizontal_else_vertical_box  stream (pp::CURSOR_RELATIVE indent); end ),  #  CONSISTENT 
            begin_wrap_box => (fn indent => pp::begin_indented_wrap_box stream (pp::CURSOR_RELATIVE indent); end ),  #  INCONSISTENT 
            end_box   => fn () => pp::end_box stream; end ,

            pps        => pp::string stream,
            break      => fn nsp_offset => pp::break stream nsp_offset; end ,
            newline    => fn () => pp::newline stream; end 
        };

    fun print_array_as_nada stream (f: pp::Stream -> X -> Void, a: Rw_Vector(X))
        =
        { my { begin_horizontal_else_vertical_box, begin_wrap_box, pps, break, end_box, ... }
                =
                en_pp stream;

            fun loop i
                = 
                { element = rw_vector::get (a, i);
                
                    pps (int::to_string i);
                    pps ": "; 
                    f stream element;
                    break { spaces=>1, indent_on_wrap=>0 };
                    loop (i+1);
                };
        
            begin_wrap_box 0;
            loop 0 except (exceptions::SUBSCRIPT|exceptions::INDEX_OUT_OF_BOUNDS) = ();
            end_box();
        };

    fun by f x y
        =
        f y x;

    fun print_tuple_as_mythrl7 stream f
        =
        print_closed_sequence_as_nada
            stream 
            {   front => by pps "(",
                sep   => fn stream =  { pps stream ", "; pp::break stream { spaces=>0, indent_on_wrap=>0 }; },
                back  => by pps ")",
                pr    => f,
                style => INCONSISTENT
            };


};              #  package print_as_nada_junk 


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext