PreviousUpNext

14.2.25  Makelib

The standard library Makelib api defines access to top-level Mythryl make / compile functionality.

The functions defined in scripting_globals are available unqualified in scripts; in non-script code they may be accessed as makelib::scripting_globals::foo.

The Makelib api is implemented by the makelib package.

The Makelib api source code is in src/lib/core/internal/makelib.api.

The above information is manually maintained and may contain errors.

api {    help : Void -> Void;
    make : String -> Bool;
    load : String -> Bool;
    compile : String -> Bool;
    freeze : String -> Bool;
    freeze' : {recursively:Bool} -> String -> Bool;
    show_all : Void -> Void;
    show_apis : Void -> Void;
    show_pkgs : Void -> Void;
    show_vals : Void -> Void;
    show_types : Void -> Void;
    show_generics : Void -> Void;
    show_controls : Void -> Void;
    show_control : String -> Void;
    set_control : String -> String -> Void;
    show_api : String -> Void;
    show_pkg : String -> Void;
    Controller X = {get:Void -> X,  set:X -> Void};
    package control : api {
                          keep_going_after_compile_errors : Controller(Bool );
                          verbose : Controller(Bool );
                          warn_on_obsolete_syntax : Controller(Bool );
                          debug : Controller(Bool );
                          conserve_memory : Controller(Bool );
                          generate_index : Controller(Bool );
                          parse_caching : Controller(Int );
                      };;
    package freezefile_db : api {
                                Freezefile ;
                                known : Void -> List(Freezefile );
                                describe : Freezefile -> String;
                                os_string : Freezefile -> String;
                                dismiss : Freezefile -> Void;
                                unshare : Freezefile -> Void;
                            };;
    package makelib_state : api {
                                clear_state : Void -> Void;
                                dump : String -> Void;
                                dump_latex : {directory:String,  filename_prefix:String, 
                                              filename_suffix:String}
                                             -> Void;
                            };;
    sources : Null_Or({architecture:String,  os:String} )
              -> String
                 -> Null_Or(
                      List({derived:Bool,  file:String,  ilk:String} ) );
    get_makelib_preprocessor_symbol_value : String -> Controller(Null_Or(Int ) );
    load_plugin : String -> Bool;
    build_executable_heap_image : ?.freeze_policy::Freeze_Policy
                                  -> {heap_filename:String,  libfile_to_run:String, 
                                      setup:Null_Or(String ),  wrapper_libfile:String}
                                     -> Null_Or(List(String ) );
    package graph : api {
                        graph : String -> Null_Or({graph:?.portable_graph::Graph, 
                                                   imports:List(freezefile_db::Freezefile ), 
                                                   nativesrc:String -> String} );
                    };;
    package scripting_globals : api {
                                    _! : multiword_int::Int -> multiword_int::Int;
                                    _[] : (?.Vector(X ) , Int) -> X;
                                    _[]:= : (?.Vector(X ) , Int , X) -> ?.Vector(X );
                                    =~ : (String , String) -> Bool;
                                    atod : String -> Float;
                                    atoi : String -> Int;
                                    back__ticks : String -> String;
                                    basename : String -> String;
                                    bash : String -> String;
                                    chdir : String -> Void;
                                    chomp : String -> String;
                                    die : String -> X;
                                    dirname : String -> String;
                                    environ : Void -> List(String );
                                    eval : String -> Void;
                                    evali : String -> Int;
                                    evalf : String -> Float;
                                    evals : String -> String;
                                    evalli : String -> List(Int );
                                    evallf : String -> List(Float );
                                    evalls : String -> List(String );
                                    exit : Int -> X;
                                    explode : String -> List(Char );
                                    factors : Int -> List(Int );
                                    fields : (Char -> Bool) -> String -> List(String );
                                    filter : (X -> Bool) -> List(X ) -> List(X );
                                    fscanf : Input_Stream
                                             -> String -> Null_Or(List(printf_field::Printf_Arg ) );
                                    getcwd : Void -> String;
                                    getenv : String -> Null_Or(String );
                                    getpid : Void -> Int;
                                    getuid : Void -> Int;
                                    geteuid : Void -> Int;
                                    getppid : Void -> Int;
                                    getgid : Void -> Int;
                                    getegid : Void -> Int;
                                    getgroups : Void -> List(Int );
                                    getlogin : Void -> String;
                                    getpgrp : Void -> Int;
                                    mkdir : (String , ?.posix_file::s::Mode) -> Void;
                                    setgid : Int -> Void;
                                    setpgid : (Int , Int) -> Void;
                                    setsid : Void -> Int;
                                    setuid : Int -> Void;
                                    implode : List(Char ) -> String;
                                    in : (''a , List(''a )) -> Bool;
                                    iseven : Int -> Bool;
                                    isodd : Int -> Bool;
                                    isprime : Int -> Bool;
                                    join' : String
                                            -> String -> String -> List(String ) -> String;
                                    join : String -> List(String ) -> String;
                                    lstat : String -> ?.posix_file::stat::Stat;
                                    now : Void -> Float;
                                    product : List(Int ) -> Int;
                                    rename : {from:String,  to:String} -> Void;
                                    rmdir : String -> Void;
                                    round : Float -> Int;
                                    shuffle' : random::Random_Number_Generator -> List(X ) -> List(X );
                                    shuffle : List(X ) -> List(X );
                                    sleep : Float -> Void;
                                    sort : ((X , X) -> Bool) -> List(X ) -> List(X );
                                    sorted : ((X , X) -> Bool) -> List(X ) -> Bool;
                                    scanf : String -> Null_Or(List(printf_field::Printf_Arg ) );
                                    sscanf : String
                                             -> String -> Null_Or(List(printf_field::Printf_Arg ) );
                                    stat : String -> ?.posix_file::stat::Stat;
                                    strcat : List(String ) -> String;
                                    strlen : String -> Int;
                                    strsort : List(String ) -> List(String );
                                    struniqsort : List(String ) -> List(String );
                                    sum : List(Int ) -> Int;
                                    symlink : {new:String,  old:String} -> Void;
                                    system : String -> Int;
                                    time : Void -> one_word_int::Int;
                                    tolower : String -> String;
                                    toupper : String -> String;
                                    tokens : (Char -> Bool) -> String -> List(String );
                                    trim : String -> String;
                                    uniquesort : ((X , X) -> Order) -> List(X ) -> List(X );
                                    unlink : String -> Void;
                                    words : String -> List(String );
                                    dot__qquotes : String -> List(String );
                                    arg0 : Void -> String;
                                    argv : Void -> List(String );
                                    isfile : String -> Bool;
                                    isdir : String -> Bool;
                                    ispipe : String -> Bool;
                                    issymlink : String -> Bool;
                                    issocket : String -> Bool;
                                    ischardev : String -> Bool;
                                    isblockdev : String -> Bool;
                                    mayread : String -> Bool;
                                    maywrite : String -> Bool;
                                    mayexecute : String -> Bool;
                                    eval_kludge_ref_int : Ref(Int );
                                    eval_kludge_ref_float : Ref(Float );
                                    eval_kludge_ref_string : Ref(String );
                                    eval_kludge_ref_list_int : Ref(List(Int ) );
                                    eval_kludge_ref_list_float : Ref(List(Float ) );
                                    eval_kludge_ref_list_string : Ref(List(String ) );
                                    version : {date:String,  system:String, 
                                               version_id:List(Int )};
                                    banner : String;
                                    exception THREAD_SCHEDULER_NOT_RUNNING;
                                    Thread ;
                                    get_current_thread : Void -> Thread;
                                    get_current_thread's_name : Void -> String;
                                    get_current_thread's_id : Void -> Int;
                                    same_thread : (Thread , Thread) -> Bool;
                                    compare_thread : (Thread , Thread) -> Order;
                                    hash_thread : Thread -> Unt;
                                    thread_to_string : Thread -> String;
                                    thread_to_name : Thread -> String;
                                    make_thread : String -> (Void -> Void) -> Thread;
                                    make_thread' : String -> (X -> Void) -> X -> Thread;
                                    thread_done : Void -> X;
                                    thread_death_mailop : Thread -> ?.internal_threadkit_types::Mailop(Void );
                                    yield : Void -> Void;
                                    make_per_thread_property : (Void -> X)
                                                               -> {clear:Void -> Void,  get:Void -> X, 
                                                                   peek:Void -> Null_Or(X ),  set:X -> Void};
                                    make_boolean_per_thread_property : Void -> {get:Void -> Bool,  set:Bool -> Void};
                                    Mailslot X;
                                    make_mailslot : Void -> Mailslot(X );
                                    same_mailslot : (Mailslot(X ) , Mailslot(X )) -> Bool;
                                    give : (Mailslot(X ) , X) -> Void;
                                    take : Mailslot(X ) -> X;
                                    give' : (Mailslot(X ) , X)
                                            -> ?.internal_threadkit_types::Mailop(Void );
                                    take' : Mailslot(X ) -> ?.internal_threadkit_types::Mailop(X );
                                    nonblocking_give : (Mailslot(X ) , X) -> Bool;
                                    nonblocking_take : Mailslot(X ) -> Null_Or(X );
                                    Maildrop X;
                                    exception MAY_NOT_FILL_ALREADY_FULL_MAILDROP;
                                    make_empty_maildrop : Void -> Maildrop(X );
                                    make_full_maildrop : X -> Maildrop(X );
                                    fill : (Maildrop(X ) , X) -> Void;
                                    empty : Maildrop(X ) -> X;
                                    empty' : Maildrop(X ) -> ?.internal_threadkit_types::Mailop(X );
                                    nonblocking_empty : Maildrop(X ) -> Null_Or(X );
                                    peek : Maildrop(X ) -> X;
                                    peek' : Maildrop(X ) -> ?.internal_threadkit_types::Mailop(X );
                                    nonblocking_peek : Maildrop(X ) -> Null_Or(X );
                                    swap : (Maildrop(X ) , X) -> X;
                                    swap' : (Maildrop(X ) , X)
                                            -> ?.internal_threadkit_types::Mailop(X );
                                    same_maildrop : (Maildrop(X ) , Maildrop(X )) -> Bool;
                                    Oneshot_Maildrop X;
                                    exception MAY_NOT_FILL_ALREADY_FULL_ONESHOT_MAILDROP;
                                    make_oneshot_maildrop : Void -> Oneshot_Maildrop(X );
                                    set : (Oneshot_Maildrop(X ) , X) -> Void;
                                    get : Oneshot_Maildrop(X ) -> X;
                                    get' : Oneshot_Maildrop(X )
                                           -> ?.internal_threadkit_types::Mailop(X );
                                    nonblocking_get : Oneshot_Maildrop(X ) -> Null_Or(X );
                                    same_oneshot_maildrop : (Oneshot_Maildrop(X ) , Oneshot_Maildrop(X )) -> Bool;
                                    Mailqueue X;
                                    make_mailqueue : Void -> Mailqueue(X );
                                    same_mailqueue : (Mailqueue(X ) , Mailqueue(X )) -> Bool;
                                    push : (Mailqueue(X ) , X) -> Void;
                                    pull : Mailqueue(X ) -> X;
                                    pull' : Mailqueue(X ) -> ?.internal_threadkit_types::Mailop(X );
                                    nonblocking_pull : Mailqueue(X ) -> Null_Or(X );
                                    Mailcaster X;
                                    Readqueue X;
                                    make_mailcaster : Void -> Mailcaster(X );
                                    make_readqueue : Mailcaster(X ) -> Readqueue(X );
                                    clone_readqueue : Readqueue(X ) -> Readqueue(X );
                                    receive : Readqueue(X ) -> X;
                                    receive' : Readqueue(X ) -> ?.internal_threadkit_types::Mailop(X );
                                    transmit : (Mailcaster(X ) , X) -> Void;
                                    Mailop X;
                                    never : Mailop(X );
                                    always_mailop : X -> Mailop(X );
                                    wrap_handler : (Mailop(X ) , (Exception -> X)) -> Mailop(X );
                                    wrap : (Mailop(X ) , (X -> Y)) -> Mailop(Y );
                                    ==> : (Mailop(X ) , (X -> Y)) -> Mailop(Y );
                                    guard : (Void -> Mailop(X )) -> Mailop(X );
                                    with_nack : (Mailop(Void ) -> Mailop(X )) -> Mailop(X );
                                    choose : List(Mailop(X ) ) -> Mailop(X );
                                    do_mailop : Mailop(X ) -> X;
                                    select : List(Mailop(X ) ) -> X;
                                    timeout_in' : time::Time -> ?.Mailop(Void );
                                    timeout_at' : time::Time -> ?.Mailop(Void );
                                    sleep_for : time::Time -> Void;
                                    sleep_until : time::Time -> Void;
                                    start_up_thread_scheduler : (Void -> Void) -> Int;
                                    start_up_thread_scheduler' : time::Time -> (Void -> Void) -> Int;
                                    thread_scheduler : (Void -> X) -> Void;
                                    thread_scheduler_is_running : Void -> Bool;
                                    shut_down_thread_scheduler : Int -> X;
                                    spawn_to_disk : (String , ((String , List(String )) -> Int)
                                                     , Null_Or(time::Time ))
                                                    -> Void;
                                    When 
                                      = APP_STARTUP | SHUTDOWN | STARTUP | THREADKIT_SHUTDOWN;
                                    at_all : List(When );
                                    note_startup_or_shutdown_action : (String , List(When ) , (When -> Void))
                                                                      -> Null_Or(((List(When ) , (When -> Void))) );
                                    forget_startup_or_shutdown_action : String
                                                                        -> Null_Or(((List(When ) , (When -> Void))) );
                                    exception NO_SUCH_ACTION;
                                    note_mailqueue : (String , mailqueue::Mailqueue(X )) -> Void;
                                    forget_mailqueue : String -> Void;
                                    note_mailslot : (String , ?.mailslot::Mailslot(X )) -> Void;
                                    forget_mailslot : String -> Void;
                                    note_imp : {at_shutdown:Void -> Void, 
                                                at_startup:Void -> Void,  name:String}
                                               -> Void;
                                    forget_imp : String -> Void;
                                    forget_all_mailslots_mailqueues_and_imps : Void -> Void;
                                };;
    redump_heap : String -> Void;
};


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext