To receive an instruction to compile something from Inbuild, and then to sort out the many locations then used in the host filing system.

• §1. Timers
• §2. The task
• §12. Project-related files and file paths

stopwatch_timer *inform7_timer = NULL, *supervisor_timer = NULL;

void Task::start_timers(void) {
    inform7_timer = Time::start_stopwatch(NULL, I"inform7 run");
    supervisor_timer = Time::start_stopwatch(inform7_timer, I"supervisor");
}
void Task::stop_timers(void) {
    Time::stop_stopwatch(inform7_timer);
}
void Task::log_stopwatch(void) {
    Time::log_timing(inform7_timer, inform7_timer->time_taken);
}

classdef compile_task_data {
    struct build_step *task;
    struct inform_project *project;

    struct pathname *path;
    struct pathname *materials;
    struct pathname *build;
    struct filename *existing_storyfile;

    int stage_of_compilation;
    int next_resource_number;
}

• The structure compile_task_data is accessed in 2/up, 2/pwst and here.

compile_task_data *inform7_task = NULL;
parse_node_tree *latest_syntax_tree = NULL;

int Task::carry_out(build_step *S) {
    int project_bundle_exists = TRUE;
    Time::stop_stopwatch(supervisor_timer);
    inform_project *project = ProjectBundleManager::from_copy(S->associated_copy);
    if (project == NULL) {
        project = ProjectFileManager::from_copy(S->associated_copy);
        project_bundle_exists = FALSE;
    }
    if (project == NULL) internal_error("no project");
    latest_syntax_tree = project->syntax_tree;

    DocReferences::read_xrefs();
    Task::issue_problems_arising(project->as_copy->vertex);
    Features::allow_activation_functions();
    Features::run_activation_functions();

    if (problem_count > 0) return FALSE;

    if (inform7_task) internal_error("cannot re-enter with new task");
    inform7_task = CREATE(compile_task_data);
    inform7_task->task = S;
    inform7_task->project = project;
    inform7_task->path = S->associated_copy->location_if_path;
    inform7_task->build = Projects::build_path(project);
    inform7_task->materials = Projects::materials_path(project);
    inform7_task->existing_storyfile = NULL;
    inform7_task->stage_of_compilation = -1;
    inform7_task->next_resource_number = 3;

    DefaultLanguage::set(Projects::get_language_of_syntax(project));
    if (project_bundle_exists) Gitignoring::automatic(project);

    int rv = Sequence::carry_out(TargetVMs::debug_enabled(inform7_task->task->for_vm));
    return rv;
}

pathname *Task::build_folder?Usage of Task::build_folder:
§13(void) {
    if (inform7_task->build)
        if (Pathnames::create_in_file_system(inform7_task->build) == FALSE)
            return NULL;
    return inform7_task->build;
}

void Task::issue_problems_arising?Usage of Task::issue_problems_arising:
§3(build_vertex *V) {
    if (V->type == COPY_VERTEX)
        SourceProblems::issue_problems_arising(V->as_copy);
    build_vertex *W;
    LOOP_OVER_LINKED_LIST(W, build_vertex, V->build_edges)
        Task::issue_problems_arising(W);
    LOOP_OVER_LINKED_LIST(W, build_vertex, V->use_edges)
        Task::issue_problems_arising(W);
}

void Task::advance_stage_to?Usage of Task::advance_stage_to:
How To Compile - §2, §2.2, §2.3, §2.4, §2.5, §2.6, §2.7, §2.8, §2.10, §2.11, §2.12, §2.13, §2.14, §2.15(int stage, text_stream *name, int X, int debugging,
    stopwatch_timer *timer) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (stage <= inform7_task->stage_of_compilation) internal_error("not an advance");
    if (stage >= 20) internal_error("went too far");
    if ((inform7_task->stage_of_compilation >= 0) && (problem_count == 0))
        PluginCalls::production_line(inform7_task->stage_of_compilation, debugging, timer);
    char *roman[] = {
        "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X",
        "XI", "XII", "XIII", "XIV", "XV", "XVI", "XVII", "XVIII", "XIX", "XX" };
    if (problem_count == 0) {
        Log::new_phase(roman[stage], name);
        if (X >= 0) ProgressBar::update(X, 0);
    }
    inform7_task->stage_of_compilation = stage;
}
int Task::is_before_stage(int stage) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (inform7_task->stage_of_compilation < stage) return TRUE;
    return FALSE;
}
int Task::is_during_stage(int stage) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (inform7_task->stage_of_compilation == stage) return TRUE;
    return FALSE;
}
int Task::is_after_stage(int stage) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (inform7_task->stage_of_compilation > stage) return TRUE;
    return FALSE;
}

inform_project *Task::project?Usage of Task::project:
§8
Internal Test Cases - §8(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->project;
}

target_vm *Task::vm?Usage of Task::vm:
§17
Compilation Settings - §4(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->task->for_vm;
}

int Task::veto_number(int X) {
    if (((X > 32767) || (X < -32768)) &&
        (TargetVMs::is_16_bit(Task::vm()))) {
        StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_LiteralOverflow),
            "you use a number which is too large",
            "at least with the Settings for this project as they currently "
            "are. (Change to Glulx to be allowed to use much larger numbers.)");
        return TRUE;
    }
    return FALSE;
}

inbuild_edition *Task::edition(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->project->as_copy->edition;
}

parse_node_tree *Task::syntax_tree?Usage of Task::syntax_tree:
§8, §16
Core Preform - §2, §3
Using Problems - §3, §3.3
Supplementary Issues - §1, §2, §3, §4, §5, §6, §7, §8, §9, §10, §11, §12, §13
Problems With Source Text - §1, §2, §3
Calculus Problems - §1
Kinds Problems - §1(void) {
    return latest_syntax_tree;
}

inform_language *Task::language_of_syntax(void) {
    return Projects::get_language_of_syntax(Task::project());
}

void Task::add_kind_inventions(void) {
    StarTemplates::transcribe_all(Task::syntax_tree());
}

void Task::verify?Usage of Task::verify:
How To Compile - §2.4(void) {
    VerifyTree::verify_integrity(Task::syntax_tree());
    VerifyTree::verify_structure(Task::syntax_tree());
}

void Task::warn_about_deprecated_nests?Usage of Task::warn_about_deprecated_nests:
How To Compile - §2.2(void) {
    inform_project *project = Task::project();
    inform_extension *ext;
    LOOP_OVER_LINKED_LIST(ext, inform_extension, project->extensions_included) {
        inbuild_nest *N = Copies::origin(ext->as_copy);
        if (Nests::is_deprecated(N)) {
            TEMPORARY_TEXT(ename)
            Copies::write_copy(ename, ext->as_copy);
            Problems::quote_stream(1, ename);
            StandardProblems::handmade_warning(Task::syntax_tree(), _p_(Untestable));
            Problems::issue_warning_segment(
                "The extension '%1' was included from an external location, that is, "
                "from outside of this project's materials folder. That's allowed, and "
                "is how most authors managed things until 2023, but we now recommend "
                "moving all extensions needed for a project (other than those built "
                "into Inform itself) into the project's materials folder. "
                "If you do, this warning will go away.");
            Problems::issue_warning_end();
        }
    }
}

int Task::get_next_free_blorb_resource_ID(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->next_resource_number++;
}

int Task::rng_seed(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->project->fix_rng;
}

void Task::make_built_in_kind_constructors?Usage of Task::make_built_in_kind_constructors:
How To Compile - §2.3(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    Projects::load_built_in_kind_constructors(inform7_task->project);
}

int Task::begin_execution_at_to_begin(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (Projects::Main_defined(inform7_task->project)) return FALSE;
    return TRUE;
}

filename *Task::uuid_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(inform7_task->path, I"uuid.txt");
}
filename *Task::ifiction_record_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(inform7_task->path, I"Metadata.iFiction");
}
filename *Task::licenses_file(int as_HTML) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (as_HTML) return Filenames::in(inform7_task->path, I"Licenses.html");
    return Filenames::in(inform7_task->path, I"Licenses.txt");
}
filename *Task::manifest_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(inform7_task->path, I"manifest.plist");
}
filename *Task::blurb_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(inform7_task->path, I"Release.blurb");
}

filename *Task::cblorb_report_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(Task::build_folder(), I"StatusCblorb.html");
}
filename *Task::parse_tree_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(Task::build_folder(), I"Parse tree.txt");
}

filename *Task::storyfile_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    build_vertex *V = inform7_task->project->unblorbed_vertex;
    if (V == NULL) return NULL;
    return V->as_file;
}

define PATH_INDEX_CALLBACK Task::index_path

pathname *Task::index_path(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    pathname *P = Pathnames::down(inform7_task->path, I"Index");
    if (Pathnames::create_in_file_system(P)) return P;
    return NULL;
}

void Task::write_XML_headings_file?Usage of Task::write_XML_headings_file:
How To Compile - §2.2(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (inform7_task->project->stand_alone == FALSE)
        Headings::write_as_XML(Task::syntax_tree(), IndexLocations::xml_headings_filename());
}

int Task::wraps_existing_storyfile(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return (inform7_task->existing_storyfile != NULL)?TRUE:FALSE;
}
void Task::set_existing_storyfile(text_stream *name) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (name == NULL) {
        TEMPORARY_TEXT(leaf)
        WRITE_TO(leaf, "story.%S", TargetVMs::get_unblorbed_extension(Task::vm()));
        inform7_task->existing_storyfile = Filenames::in(inform7_task->materials, leaf);
        DISCARD_TEXT(leaf)
    } else {
        inform7_task->existing_storyfile = Filenames::in(inform7_task->materials, name);
    }
}
filename *Task::existing_storyfile_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->existing_storyfile;
}

filename *Task::large_cover_art_file(int JPEG) {
    if (inform7_task == NULL) internal_error("there is no current task");
    if (JPEG) return Filenames::in(inform7_task->materials, I"Cover.jpg");
    return Filenames::in(inform7_task->materials, I"Cover.png");
}
filename *Task::epsmap_file(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Filenames::in(inform7_task->materials, I"Inform Map.eps");
}

pathname *Task::resources_path(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return inform7_task->materials;
}

text_stream *Task::figures_department(void) {
    return I"Figures";
}
text_stream *Task::sounds_department(void) {
    return I"Sounds";
}
text_stream *Task::data_department(void) {
    return I"Data";
}

pathname *Task::release_path(void) {
    if (inform7_task == NULL) internal_error("there is no current task");
    return Pathnames::down(inform7_task->materials, I"Release");
}
pathname *Task::released_figures_path(void) {
    return Pathnames::down(Task::release_path(), I"Figures");
}
pathname *Task::released_sounds_path(void) {
    return Pathnames::down(Task::release_path(), I"Sounds");
}
pathname *Task::released_interpreter_path(void) {
    return Pathnames::down(Task::release_path(), I"interpreter");
}

int write_EPS_format_map = FALSE;

int do_not_generate_index = FALSE; /* Set by the -no-index command line option */
void Task::disable_or_enable_index(int which) {
    do_not_generate_index = which;
}
int do_not_generate_problems = FALSE; /* Set by the -no-problems command line option */
void Task::disable_or_enable_problems(int which) {
    do_not_generate_problems = which;
}
int do_not_update_extensions_index = FALSE; /* Also set by the -no-index command line option */
void Task::disable_or_enable_extensions_update(int which) {
    do_not_update_extensions_index = which;
}

int Task::problems_enabled(void) {
    return do_not_generate_problems?FALSE:TRUE;
}

int inform7_index_requirements = 0;
void Task::specify_index_requirements?Usage of Task::specify_index_requirements:
How To Compile - §2.15(void) {
    inform7_index_requirements = 0;
    if (do_not_generate_index == FALSE)
        inform7_index_requirements |= INDEX_REQUIRED_BIT;
    if (do_not_update_extensions_index == FALSE)
        inform7_index_requirements |= EXTENSIONS_INDEX_REQUIRED_BIT;
    if (write_EPS_format_map)
        inform7_index_requirements |= EPS_MAP_REQUIRED_BIT;
}

int Task::get_index_requirements(void) {
    return inform7_index_requirements;
}