PreviousUpNext

15.4.706  src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode-g.pkg

## translate-raw-syntax-to-execode-g.pkg 
#
# Our apis
#              Translate_Raw_Syntax_To_Execode_0
#              Translate_Raw_Syntax_To_Execode
#     Toplevel_Translate_Raw_Syntax_To_Execode
#
# are all defined in
#
#     src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode.api
#
# Our generic is invoked (twice) from
#
#     src/lib/compiler/toplevel/compiler/mythryl-compiler-g.pkg
#
# generic arguments:
#
#     package backend
#         is the machine-dependent code generator
#         for our platform.
#
#     package compiler_configuration
#         is compiler configuration stuff used to
#         select between interactive compiling into
#         memory and production compiling to a .compiled file.
#
#         It mainly selects whether we pickle, unpickle
#         and generate a picklehash for everything we
#         compile (regular batch-mode compilation) or
#         just skip that stuff and compile direct into
#         our heap (interactive compilation).
#
#
#
# Our canonical 'translate_raw_syntax_to_execode' entrypoint is from:
#
#     src/app/makelib/compile/compile-in-dependency-order-g.pkg

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





###               "I had a running compiler and nobody would touch it.
###                They told me computers could only do arithmetic."
###
###                                  -- Rear Admiral Grace Hopper



###               "Every sufficiently good analogy is yearning to become a functor."
###
###                                  -- John Baez
###                                     http://math.ucr.edu/home/baez/quantum/node2.html


stipulate
    package cos =  compile_statistics;                                  # compile_statistics                            is from   src/lib/compiler/front/basics/stats/compile-statistics.pkg
    package cs  =  code_segment;                                        # code_segment                                  is from   src/lib/compiler/execution/code-segments/code-segment.pkg
    package d2l =  translate_deep_syntax_to_lambdacode;                 # translate_deep_syntax_to_lambdacode           is from   src/lib/compiler/back/top/translate/translate-deep-syntax-to-lambdacode.pkg
    package ds  =  deep_syntax;                                         # deep_syntax                                   is from   src/lib/compiler/front/typer-stuff/deep-syntax/deep-syntax.pkg
    package im  =  inlining_mapstack;                                   # inlining_mapstack                             is from   src/lib/compiler/toplevel/compiler-state/inlining-mapstack.pkg
    package inj =  inlining_junk;                                       # inlining_junk                                 is from   src/lib/compiler/front/semantic/basics/inlining-junk.pkg
    package l2a =  translate_lambdacode_to_anormcode;                   # translate_lambdacode_to_anormcode             is from   src/lib/compiler/back/top/lambdacode/translate-lambdacode-to-anormcode.pkg
    package lsi =  lambdasplit_inlining;                                # lambdasplit_inlining                          is from   src/lib/compiler/back/top/lsplit/lambdasplit-inlining.pkg
    package pcs =  per_compile_stuff;                                   # per_compile_stuff                             is from   src/lib/compiler/front/typer-stuff/main/per-compile-stuff.pkg
    package pp  =  standard_prettyprinter;                              # standard_prettyprinter                        is from   src/lib/prettyprint/big/src/standard-prettyprinter.pkg
#   package pu  =  unparse_junk;                                        # unparse_junk                                  is from   src/lib/compiler/front/typer/print/unparse-junk.pkg
    package raw =  raw_syntax;                                          # raw_syntax                                    is from   src/lib/compiler/front/parser/raw-syntax/raw-syntax.pkg
    package sci =  sourcecode_info;                                     # sourcecode_info                               is from   src/lib/compiler/front/basics/source/sourcecode-info.pkg
    package sp  =  add_per_fun_byte_counters_to_deep_syntax;            # add_per_fun_byte_counters_to_deep_syntax      is from   src/lib/compiler/debugging-and-profiling/profiling/add-per-fun-byte-counters-to-deep-syntax.pkg
    package ss  =  special_symbols;                                     # special_symbols                               is from   src/lib/compiler/front/typer/main/special-symbols.pkg
    package syx =  symbolmapstack;                                      # symbolmapstack                                is from   src/lib/compiler/front/typer-stuff/symbolmapstack/symbolmapstack.pkg
    package ti  =  tdp_instrument;                                      # tdp_instrument                                is from   src/lib/compiler/debugging-and-profiling/profiling/tdp-instrument.pkg
    package tmp =  highcode_codetemp;                                   # highcode_codetemp                             is from   src/lib/compiler/back/top/highcode/highcode-codetemp.pkg
    package tp  =  add_per_fun_call_counters_to_deep_syntax;            # add_per_fun_call_counters_to_deep_syntax      is from   src/lib/compiler/debugging-and-profiling/profiling/add-per-fun-call-counters-to-deep-syntax.pkg
    package r2d =  translate_raw_syntax_to_deep_syntax;                 # translate_raw_syntax_to_deep_syntax           is from   src/lib/compiler/front/semantic/typecheck/translate-raw-syntax-to-deep-syntax.pkg
    package pds =  prettyprint_deep_syntax;                             # prettyprint_deep_syntax                       is from   src/lib/compiler/front/typer/print/prettyprint-deep-syntax.pkg
    package uds =  unparse_deep_syntax;                                 # unparse_deep_syntax                           is from   src/lib/compiler/front/typer/print/unparse-deep-syntax.pkg
    package vh  =  varhome;                                             # varhome                                       is from   src/lib/compiler/front/typer-stuff/basics/varhome.pkg

    Pp = pp::Pp;
herein
                                                                        # backend                                       can be     backend_pwrpc32          from   src/lib/compiler/back/low/main/pwrpc32/backend-pwrpc32.pkg
                                                                        # backend                                       can be     backend_sparc32          from   src/lib/compiler/back/low/main/sparc32/backend-sparc32.pkg
                                                                        # backend                                       can be     backend_intel32_g   call from   src/lib/compiler/toplevel/compiler/mythryl-compiler-for-intel32-posix.pkg
                                                                        # backend                                       can be     backend_intel32_g   call from   src/lib/compiler/toplevel/compiler/mythryl-compiler-for-intel32-win32.pkg
    # This generic is (only) invoked (twice) from:
    #
    #     src/lib/compiler/toplevel/compiler/mythryl-compiler-g.pkg
    #
    generic package  translate_raw_syntax_to_execode_g (
        #
        package backend:                Backend;                        # Backend                                       is from   src/lib/compiler/toplevel/main/backend.api
        package compiler_configuration: Compiler_Configuration;         # Compiler_Configuration                        is from   src/lib/compiler/toplevel/main/compiler-configuration.api
        #
        ansi_c_prototype_convention:  String;                           #  "unix_convention" "windows_convention" or "unimplemented" 
    )
    : (weak) Translate_Raw_Syntax_To_Execode_0                          # Translate_Raw_Syntax_To_Execode_0             is from   src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode.api
    {
        # Local abbreviations:
        #
        package bak =  backend;
        package cc  =  compiler_configuration;                          
        #
        fun make_per_compile_stuff { sourcecode_info, deep_syntax_transform, prettyprinter_or_null, compiler_verbosity }
            =
            pcs::make_per_compile_stuff
              {
                sourcecode_info,
                deep_syntax_transform,
                make_fresh_stamp_maker =>  cc::make_fresh_stamp_maker,
                prettyprinter_or_null,
                compiler_verbosity
              };


        Pickle     =   cc::Pickle;              #  pickled format 
        Hash       =   cc::Hash;                #  Dictionary hash id 
        Picklehash =   cc::Picklehash;

        Compiledfile_Version =   cc::Compiledfile_Version;


        ##########################################################################
        #                             Debug/visulize/log support                 #
        ##########################################################################
        #
        fun maybe_prettyprint_anormcode  (
                per_compile_stuff:   pcs::Per_Compile_Stuff( ds::Declaration ),
                anormcode
            )
            =
            {   per_compile_stuff ->   { prettyprinter_or_null, compiler_verbosity, ... }
;
                case prettyprinter_or_null
                    #
                    NULL => ();
                    #
                    THE pp
                        =>
                        if compiler_verbosity.pprint_anormcode_tree
                            pp.newline();
                            pp.newline();
#                           pp.lit   "(Following printed by src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode-g.pkg.)";
                            pp.lit   "(Following";
                            pp::break    pp   { blanks => 1, indent_on_wrap => 1 };
                            pp.lit   "printed";
                            pp::break    pp   { blanks => 1, indent_on_wrap => 1 };
                            pp.lit   "by";
                            pp::break    pp   { blanks => 1, indent_on_wrap => 1 };
                            pp.lit   "src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode-g.pkg.)";

                            pp.newline();
                            pp.newline();
                            pp.lit   "A-Normal form:";
                            pp.newline();

                            prettyprint_anormcode::prettyprint_prog   pp   anormcode;

                            pp.flush ();
                        fi;
                esac;
            };

        #
        fun maybe_prettyprint_elapsed_time   (per_compile_stuff:   pcs::Per_Compile_Stuff( ds::Declaration ))
            =
            {   per_compile_stuff ->   { prettyprinter_or_null, ... };

                case prettyprinter_or_null
                    #
                    NULL => ();
                    #
                    THE pp
                        =>
                        {   pp.newline();
                            pp.newline();       
                            pp.lit   "Elapsed time not yet implemented";
                            pp.newline();
                        };
                esac;
            };


        ##########################################################################
        #                             Typechecking                               #
        ##########################################################################

        # Several preprocessing phases done
        # after parsing or after typechecking:

    #    my fixityparse
    #        =
    #   # cos::do_compiler_phase (cos::make_compiler_phase "Compiler 005 fixityparse")
    #   FixityParse::fixityparse
    #
    #    my lazycomp
    #        =
    #   #  cos::do_compiler_phase (cos::make_compiler_phase "Compiler 006 lazycomp") 
    #       LazyComp::lazycomp


        pickle_unpickle
            =
            cos::do_compiler_phase
                (cos::make_compiler_phase "Compiler 036  pickle_unpickle")
                cc::pickle_unpickle;


                                                                                                # compile_statistics    is from   src/lib/compiler/front/basics/stats/compile-statistics.pkg

        # Take raw_declaration, do semantic checks, and return
        # the new symbol table, deep_syntax_declaration and pickles:
        #
        fun typecheck_raw_declaration {
                #
                raw_declaration:                raw::Declaration,                               # Actual raw syntax to compile.
                symbolmapstack:                 syx::Symbolmapstack,                            # Symbol table containing info from all .compiled files we depend on.
                per_compile_stuff:              pcs::Per_Compile_Stuff( ds::Declaration ),
                compiledfile_version:           Compiledfile_Version,
                sourcecode_info:                sci::Sourcecode_Info
            }
            =
            { deep_syntax_declaration,        # ds::Declaration,                                # Typechecked form of  raw_declaration.
              new_symbolmapstack,             # syx::Symbolmapstack,                            # A symbol table delta containing (only) stuff from raw_declaration.
              export_picklehash,              # Null_Or( Picklehash ),
              exported_highcode_variables,    # List( vh::Variable ),
              symbolmapstack_picklehash,      # Hash,
              pickle                          # Pickle          
            }
            where
                per_compile_stuff ->   { prettyprinter_or_null, compiler_verbosity, ... };

if *log::debugging  printf "calling translate_raw_syntax_to_deep_syntax   [translate-raw-syntax-to-execode-g.pkg]\n"; fi;
                (r2d::translate_raw_syntax_to_deep_syntax                                       # translate_raw_syntax_to_deep_syntax   def in   src/lib/compiler/front/typer/main/translate-raw-syntax-to-deep-syntax-g.pkg
                    (
                      raw_declaration,                                                          # Actual raw syntax to compile.
                      symbolmapstack,                                                           # Symbol table containing info from all .compiled files we depend on.
                      per_compile_stuff
                    ))
                    ->
                    ( deep_syntax_declaration,                                                  # This is the typechecked version of  raw_declaration.
                      new_symbolmapstack                                                        # A symbol table delta containing (only) stuff from raw_declaration.
                    );
if *log::debugging  printf "called  translate_raw_syntax_to_deep_syntax   [translate-raw-syntax-to-execode-g.pkg]\n"; fi;


                my (deep_syntax_declaration, new_symbolmapstack)
                    =
                    if (pcs::saw_errors  per_compile_stuff)
                        #
                        (ds::SEQUENTIAL_DECLARATIONS NIL, syx::empty);
                    else
                        (deep_syntax_declaration,         new_symbolmapstack);
                    fi;




                (pickle_unpickle                                                                # pickle_unpickle def in   src/lib/compiler/toplevel/compiler/mythryl-compiler-g.pkg
                    {
                      context        =>  symbolmapstack,                                        # Combined symbol tables of all .compiled files we depend upon.
                      symbolmapstack =>  new_symbolmapstack,                                    # Symbol table to pickle-then-unpickle.
                      compiledfile_version
                    })
                    ->
                    { picklehash => symbolmapstack_picklehash,
                      pickle,
                      exported_highcode_variables,
                      export_picklehash,
                      new_symbolmapstack
                     };


                # Prettyprint to logfile if so requested:
                #
                case prettyprinter_or_null
                    #
                    NULL => ();

                    THE pp
                        =>
                        {   if (pcs::saw_errors  per_compile_stuff)
                                #
                                pp.newline();
                                pp.newline();
                                pp.lit   "(Due to syntax errors, no deep syntax tree or new symbol table available.)\n";
                                pp.newline();
                                pp::flush_prettyprinter  pp;
                            else 
                                if compiler_verbosity.pprint_symbol_table
                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "(Following printed by typecheck_raw_declaration in src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode-g.pkg.)";
                                    pp.newline();

                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "ansi_c_prototype_convention:  ";
                                    pp.lit   ansi_c_prototype_convention;
                                    pp.newline();

                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "Original symbol table:";
                                    pp.newline();

                                                                                    # prettyprint_symbolmapstack                is from   src/lib/compiler/front/typer-stuff/symbolmapstack/prettyprint-symbolmapstack.pkg

                                    prettyprint_symbolmapstack::prettyprint_symbolmapstack     pp   symbolmapstack;
                                    pp.newline();

                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "New symbol table:";
                                    pp.newline();

                                    prettyprint_symbolmapstack::prettyprint_symbolmapstack     pp   new_symbolmapstack;
                                    pp.newline();

                                    pp::flush_prettyprinter  pp;
                                fi;

                                if compiler_verbosity.print_exported_highcode_variables
                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "exported_highcode_variables:";
                                    pp.newline();
                                    print_lv_list  exported_highcode_variables
                                    where
                                        fun print_lv_list  (lv ! rest)
                                                =>
                                                {   pp.lit   "    ";
                                                    pp.lit   (tmp::to_string lv);
                                                    #
                                                    if  (tmp::highcode_codetemp_has_a_name  lv)
                                                        pp.lit   "  (";
                                                        pp.lit   (tmp::name_of_highcode_codetemp  lv);
                                                        pp.lit   ")";
                                                    fi;
                                                    pp.newline();
                                                };  

                                            print_lv_list  []   =>   ();
                                        end; 
                                    end;
                                    pp::flush_prettyprinter  pp;
                                fi;

                                if compiler_verbosity.unparse_deep_syntax_tree
                                    pp.newline();
                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "Deep syntax tree, unparsed:    -- translate-raw-syntax-to-execode-g.pkg";
                                    pp.newline();
                                    #
                                    uds::unparse_declaration
                                        #
                                        (new_symbolmapstack, THE sourcecode_info)
                                        pp
                                        (deep_syntax_declaration, 38);          # 1000 is the maximum expression nesting depth to print -- arbitrary large number.
                                    pp::flush_prettyprinter  pp;
                                fi;

                                if compiler_verbosity.pprint_deep_syntax_tree
                                    pp.newline();
                                    pp.newline();
                                    pp.newline();
                                    pp.lit   "Deep syntax tree, prettyprinted:    -- translate-raw-syntax-to-execode-g.pkg";
                                    pp.newline();
                                    #
                                    pds::prettyprint_declaration
                                        #
                                        (new_symbolmapstack, THE sourcecode_info)
                                        pp
                                        (deep_syntax_declaration, 38);          # 1000 is the maximum expression nesting depth to print -- arbitrary large number.
                                    pp::flush_prettyprinter  pp;
                                fi;
                            fi;

# pp.lit   "(Above printed by typecheck_raw_declaration in src/lib/compiler/toplevel/main/translate-raw-syntax-to-execode-g.pkg.)";
# pp.newline();
# pp::flush_prettyprinter  pp;

                        };
                esac;
            end;                                                                # fun typecheck_raw_declaration

        typecheck_raw_declaration
            =
            cos::do_compiler_phase (cos::make_compiler_phase "Compiler 030  typecheck") typecheck_raw_declaration;



        #########################################################################
        #                        Deep_Syntax INSTRUMENTATION                    #
        #########################################################################

                                                    # special_symbols   is from   src/lib/compiler/front/typer/main/special-symbols.pkg
        stipulate

            is_special
                =
                \\ s =  list::exists (\\ s' =  symbol::eq (s, s'))  specials_list
                where
                    specials_list
                      =
                      [ ss::param_id,
                        ss::generic_id,
                        ss::hidden_id,
                        ss::temp_package_id,
                        ss::temp_generic_id,
                        ss::generic_body_id,
                        ss::anonymous_generic_api_id,
                        ss::result_id,
                        ss::return_id,
                        ss::internal_var_id
                      ];
                end;
                                                    # list                      is from   src/lib/std/src/list.pkg
        herein

            # Instrumenting the deep syntax to do time- and space-profiling:    # This is off by default;  controlled by        if *runtime_internals::runtime_profiling_control::profiling_mode
            #                                                                   # runtime_internals                             is from   src/lib/std/src/nj/runtime-internals.pkg
            #                                                                   # profiling_mode                                def in    src/lib/std/src/nj/runtime-profiling-control.pkg
            #
            fun maybe_instrument_deep_syntax
                  {
                    sourcecode_info,
                    symbolmapstack,
                    per_compile_stuff
                  }
                = sp::maybe_add_per_fun_byte_counters_to_deep_syntax                          (symbolmapstack, per_compile_stuff) sourcecode_info       # This is junk code that probably should be deleted.
                o tp::maybe_add_per_fun_call_counters_to_deep_syntax  inj::is_callcc_baseop   (symbolmapstack, per_compile_stuff)                       # This adds logic to each function to count calls to it.
                o ti::maybe_instrument_deep_syntax                    is_special              (symbolmapstack, per_compile_stuff);
        end;

                                                    # add_per_fun_byte_counters_to_deep_syntax                  is from   src/lib/compiler/debugging-and-profiling/profiling/add-per-fun-byte-counters-to-deep-syntax.pkg
                                                    # add_per_fun_call_counters_to_deep_syntax                  is from   src/lib/compiler/debugging-and-profiling/profiling/add-per-fun-call-counters-to-deep-syntax.pkg
                                                    # tdp_instrument            is from   src/lib/compiler/debugging-and-profiling/profiling/tdp-instrument.pkg


        maybe_instrument_deep_syntax
            =
            cos::do_compiler_phase (cos::make_compiler_phase "Compiler 039  maybe_instrument_deep_syntax") maybe_instrument_deep_syntax;



        #########################################################################
        #                       TRANSLATION INTO ANORMCODE                        #
        #########################################################################

        # Accept a typechecked deep syntax declaration
        # and generate corresponding A-Normal code:
        #
        fun translate_deep_syntax_to_anormcode {
                deep_syntax_declaration,
                exported_highcode_variables,
                new_symbolmapstack,
                old_symbolmapstack,
                per_compile_stuff
            }
            =

                                                    # symbolmapstack                            is from   src/lib/compiler/front/typer-stuff/symbolmapstack/symbolmapstack.pkg


            {   symbolmapstack                  # symbolmapstack used for printing deep_syntax in messages.
                    =
                    syx::atop (new_symbolmapstack, old_symbolmapstack);

if *log::debugging      printf "translate_deep_syntax_to_anormcode calling translate_deep_syntax_to_lambdacode   -- translate-raw-syntax-to-execode.pkg\n";     fi;
                my { lambdacode_expression, imports }
                    = 
                    d2l::translate_deep_syntax_to_lambdacode
                        {
                          declaration => deep_syntax_declaration,
                          exported_highcode_variables,
                          symbolmapstack,
                          ansi_c_prototype_convention,        #  "unix_convention" "windows_convention" or "unimplemented" 
                          per_compile_stuff
                        };



if *log::debugging      printf "translate_deep_syntax_to_anormcode calling translate_lambdacode_to_anormcode   -- translate-raw-syntax-to-execode.pkg\n";       fi;
                # Normalize the lambdacode expression
                # into A-Normal form:
                #
                anormcode
                    =
                    l2a::translate_lambdacode_to_anormcode
                        #
                        lambdacode_expression;

if *log::debugging      printf "translate_deep_syntax_to_anormcode returning.   -- translate-raw-syntax-to-execode.pkg\n";      fi;
                { anormcode, imports };
            };

        translate_deep_syntax_to_anormcode
            =
            cos::do_compiler_phase (cos::make_compiler_phase "Compiler 040  translate") translate_deep_syntax_to_anormcode; 


        #########################################################################
        #                       CODE GENERATION                                 #
        #########################################################################

        # Compile A-Normal form down to nextcode
        # and thence all the way to native binary:

                                                    # translate_anormcode_to_execode    def in    src/lib/compiler/back/top/main/backend-tophalf-g.pkg
        stipulate
            increment_codebytes_count_by
                =
                cos::increment_counterssum_by (cos::make_counterssum' "Code Size");
        herein
            #
            fun translate_anormcode_to_execode { anormcode, imports, inlining_mapstack, crossmodule_inlining_aggressiveness, per_compile_stuff }
                =
                { code_and_data_segments => segs,
                  inline_expression,
                  import_trees           =>  revised_import_trees
                }
                where
if *log::debugging      printf "translate_anormcode_to_execode/top.   -- translate-raw-syntax-to-execode.pkg\n";        fi;
                    #  Do cross-module inlining and specialization: 
                    #
                    (lsi::do_lambdasplit_inlining (anormcode, imports, inlining_mapstack))
                        ->
                        (anormcode, revised_import_trees);
                        

                    #  from finished A-Normal code, generate the machine code.  

                    my  ( segs: cs::Code_And_Data_Segments,
                          inline_expression
                        )
                        =
                        bak::translate_anormcode_to_execode (           # Defined in src/lib/compiler/back/top/main/backend-tophalf-g.pkg
                            anormcode,
                            per_compile_stuff,
                            crossmodule_inlining_aggressiveness
                        );

                    #  Obey the nosplit directive used during bootstrapping.  

                    # inline_expression
                    #     =
                    #     if (not_null  crossmodule_inlining_aggressivenss)  inline_expression
                    #     else                                                NULL;     #  XXX BUGGO FIXME WTF?
                    #     fi;

                    bytes_of_code
                        =
                        cs::get_machinecode_bytevector_size_in_bytes  segs.code_segment
                        +
                        vector_of_one_byte_unts::length  segs.bytecodes_to_regenerate_literals_vector;



                                                                        # list                  is from   src/lib/std/src/list.pkg
                                                                        # vector_of_one_byte_unts               is from   src/lib/std/src/vector-of-one-byte-unts.pkg

                    increment_codebytes_count_by  bytes_of_code;
if *log::debugging      printf "translate_anormcode_to_execode/bot.   -- translate-raw-syntax-to-execode.pkg\n";        fi;
                end;
        end;                                                            # stipulate translate_anormcode_to_execode 


#       translate_anormcode_to_execode
#           =
#           cos::do_compiler_phase (cos::make_compiler_phase "Compiler 140 translate_anormcode_to_execode") translate_anormcode_to_execode


        ###########################################################################
        #                         COMPILATION                                  
        #        = TYPECHECKING + TRANSLATION TO HIGHCODE + CODE GENERATION    
        # used only by interact/read-eval-print-loop-g.pkg                    
        # and          src/app/makelib/compile/compile-in-dependency-order-g.pkg       
        ###########################################################################


        # Compiling the raw_declaration into absolute executable machine code.
        #
        # Our canonical invokation is in
        #
        #     src/app/makelib/compile/compile-in-dependency-order-g.pkg
        #
        fun translate_raw_syntax_to_execode
              {
                sourcecode_info:                        sci::Sourcecode_Info,
                raw_declaration:                        raw::Declaration,                               # Actual raw syntax to compile.
                symbolmapstack:                         syx::Symbolmapstack,                            # Symbol table containing info from all .compiled files we depend on.
                inlining_mapstack:                      im::Picklehash_To_Anormcode_Mapstack,           # Inlining table matching symbolmapstack.
                per_compile_stuff:                      pcs::Per_Compile_Stuff( ds::Declaration ),      # E.g., counting and reporting of compile errors.
                handle_compile_errors => check,
                crossmodule_inlining_aggressiveness:    Null_Or( Int ),                                 # This gets used in   src/lib/compiler/back/top/improve/do-crossmodule-anormcode-inlining.pkg
                compiledfile_version:                   Compiledfile_Version
              }
            = 
              { code_and_data_segments,
                new_symbolmapstack,                                                                     # A symbol table delta containing (only) stuff from raw_declaration.
                deep_syntax_declaration,                                                                # Typechecked form of  raw_declaration.

                export_picklehash,
                exported_highcode_variables,
                symbolmapstack_picklehash,

                pickle,
                inline_expression,
                import_trees          => revised_import_trees
              }
            where


                (typecheck_raw_declaration
                    {   raw_declaration,                                                                # Actual raw syntax to compile.
                        symbolmapstack,                                                                 # Symbol table containing info from all .compiled files we depend on.
                        per_compile_stuff,
                        compiledfile_version,
                        sourcecode_info
                    }
                 then (check "typecheck")
                )
                    ->
                    { deep_syntax_declaration,                                                          # Typechecked form of  raw_declaration.
                      new_symbolmapstack,                                                               # A symbol table delta containing (only) stuff from raw_declaration.
                      exported_highcode_variables,
                      export_picklehash,
                      symbolmapstack_picklehash,
                      pickle
                    };



               (maybe_instrument_deep_syntax
                  {
                    sourcecode_info,
                    symbolmapstack,
                    per_compile_stuff
                  }
                  deep_syntax_declaration
                then
                    (check "maybe_instrument_deep_syntax")
               )
                    ->
                    deep_syntax_declaration;



                (translate_deep_syntax_to_anormcode
                  {
                    deep_syntax_declaration,                                                            # Typechecked form of  raw_declaration.
                    exported_highcode_variables, 
                    new_symbolmapstack,                                                                 # A symbol table delta containing (only) stuff from raw_declaration.
                    old_symbolmapstack => symbolmapstack,                                               # Symbol table containing info from all .compiled files we depend on.
                    per_compile_stuff
                  }
                then
                    check "translate_deep_syntax_to_anormcode"
                )
                    ->
                    { anormcode, imports };


                maybe_prettyprint_anormcode  (per_compile_stuff, anormcode);

                (translate_anormcode_to_execode
                  {
                    anormcode,
                    imports,
                    inlining_mapstack,
                    crossmodule_inlining_aggressiveness,
                    per_compile_stuff
                  }
                then
                    (check "translate_anormcode_to_execode")
                )
                    ->
                    { code_and_data_segments,
                      inline_expression,
                      import_trees => revised_import_trees
                    };
            end;                                                # function translate_raw_syntax_to_execode
    };                                                          # generic package translate_raw_syntax_to_execode_g 
end;






Comments and suggestions to: bugs@mythryl.org

PreviousUpNext