//
// The linker
//

#include "always.h"
#include "ml.h"
#include "link.h"
#include "sysvar.h"
#include "st.h"






//
// The data we accumulate as we link.
// 

SLONG            *LINK_instruction;
SLONG             LINK_instruction_max;
SLONG             LINK_instruction_upto;

CBYTE            *LINK_table_data;
SLONG             LINK_table_data_max;
SLONG             LINK_table_data_upto;

LINK_Global      *LINK_global;
SLONG             LINK_global_max;
SLONG             LINK_global_upto;

LINK_Function    *LINK_function;
SLONG             LINK_function_max;
SLONG             LINK_function_upto;

LINK_Line        *LINK_line;
SLONG             LINK_line_max;
SLONG             LINK_line_upto;

LINK_Jump        *LINK_jump;
SLONG             LINK_jump_max;
SLONG             LINK_jump_upto;

LINK_Field       *LINK_field;
SLONG             LINK_field_max;
SLONG             LINK_field_upto;

LINK_Globalref   *LINK_global_ref;
SLONG             LINK_global_ref_max;
SLONG             LINK_global_ref_upto;

LINK_Undefref    *LINK_undef_ref;
SLONG             LINK_undef_ref_max;
SLONG             LINK_undef_ref_upto;

LINK_Fieldref     *LINK_field_ref;
SLONG              LINK_field_ref_max;
SLONG              LINK_field_ref_upto;

LINK_Datatableref *LINK_data_table_ref;
SLONG              LINK_data_table_ref_max;
SLONG              LINK_data_table_ref_upto;

CBYTE            *LINK_debug_data;
SLONG             LINK_debug_data_max;
SLONG             LINK_debug_data_upto;

//
// Each file.
//

typedef struct
{
	SLONG first_instruction;
	SLONG num_instructions;

	SLONG first_table_datum;
	SLONG num_table_data;

	SLONG first_global;
	SLONG num_globals;

	SLONG first_function;
	SLONG num_functions;

	SLONG first_line;
	SLONG num_lines;

	SLONG first_jump;
	SLONG num_jumps;

	SLONG first_field;
	SLONG num_fields;

	SLONG first_global_ref;
	SLONG num_global_refs;
	
	SLONG first_undef_ref;
	SLONG num_undef_refs;

	SLONG first_field_ref;
	SLONG num_field_refs;

	SLONG first_data_table_ref;
	SLONG num_data_table_refs;

	SLONG first_debug_datum;
	SLONG num_debug_data;

} LINK_File;

LINK_File *LINK_file;
SLONG      LINK_file_max;
SLONG      LINK_file_upto;



//
// The number of globals and fields in the executable.
// 

SLONG LINK_global_id_upto;
SLONG LINK_field_id_upto;








//
// Allocates initial memory.
//

void LINK_allocate_memory(void)
{
	LINK_instruction_max  = 1;
	LINK_instruction_upto = 0;
	LINK_instruction      = (SLONG *) malloc(sizeof(SLONG) * LINK_instruction_max);

	LINK_table_data_max  = 1;
	LINK_table_data_upto = 0;
	LINK_table_data      = (CBYTE *) malloc(sizeof(CBYTE) * LINK_table_data_max);

	LINK_global_max  = 1;
	LINK_global_upto = 0;
	LINK_global      = (LINK_Global *) malloc(sizeof(LINK_Global) * LINK_global_max);

	LINK_function_max  = 1;
	LINK_function_upto = 0;
	LINK_function      = (LINK_Function *) malloc(sizeof(LINK_Function) * LINK_function_max);

	LINK_line_max  = 1;
	LINK_line_upto = 0;
	LINK_line      = (LINK_Line *) malloc(sizeof(LINK_Line) * LINK_line_max);

	LINK_jump_max  = 1;
	LINK_jump_upto = 0;
	LINK_jump      = (LINK_Jump *) malloc(sizeof(LINK_Jump) * LINK_jump_max);

	LINK_field_max  = 1;
	LINK_field_upto = 0;
	LINK_field      = (LINK_Field *) malloc(sizeof(LINK_Field) * LINK_field_max);

	LINK_global_ref_max  = 1;
	LINK_global_ref_upto = 0;
	LINK_global_ref      = (LINK_Globalref *) malloc(sizeof(LINK_Globalref) * LINK_global_ref_max);

	LINK_undef_ref_max  = 1;
	LINK_undef_ref_upto = 0;
	LINK_undef_ref      = (LINK_Undefref *) malloc(sizeof(LINK_Undefref) * LINK_undef_ref_max);

	LINK_field_ref_max  = 1;
	LINK_field_ref_upto = 0;
	LINK_field_ref      = (LINK_Fieldref *) malloc(sizeof(LINK_Fieldref) * LINK_field_ref_max);

	LINK_data_table_ref_max  = 1;
	LINK_data_table_ref_upto = 0;
	LINK_data_table_ref      = (LINK_Datatableref *) malloc(sizeof(LINK_Datatableref) * LINK_data_table_ref_max);

	LINK_debug_data_max  = 1;
	LINK_debug_data_upto = 0;
	LINK_debug_data      = (CBYTE *) malloc(sizeof(CBYTE) * LINK_debug_data_max);

	LINK_file_max  = 1;
	LINK_file_upto = 0;
	LINK_file      = (LINK_File *) malloc(sizeof(LINK_File) * LINK_file_max);
	
}


//
// Frees all memory.
//

void LINK_free_memory(void)
{
	free(LINK_instruction   );
	free(LINK_table_data    );
	free(LINK_global        );
	free(LINK_function      );
	free(LINK_line          );
	free(LINK_jump          );
	free(LINK_field         );
	free(LINK_global_ref    );
	free(LINK_undef_ref     );
	free(LINK_field_ref     );
	free(LINK_data_table_ref);
	free(LINK_debug_data    );
	free(LINK_file          );

	LINK_instruction    = NULL;
	LINK_table_data     = NULL;
	LINK_global         = NULL;
	LINK_function       = NULL;
	LINK_line           = NULL;
	LINK_jump           = NULL;
	LINK_field          = NULL;
	LINK_global_ref     = NULL;
	LINK_undef_ref      = NULL;
	LINK_field_ref      = NULL;
	LINK_data_table_ref = NULL;
	LINK_debug_data     = NULL;
	LINK_file           = NULL;
}








SLONG LINK_do(CBYTE *object_fname[], SLONG num_object_files, CBYTE *exec_fname)
{
	SLONG i;
	SLONG j;
	SLONG instruction;
	SLONG magic;

	LINK_Header        lh;
	LINK_File         *lf;
	LINK_Function     *lc;
	LINK_Jump         *lj;
	LINK_Global       *lg;
	LINK_Field        *ld;
	LINK_Undefref     *lu;
	LINK_Datatableref *lt;
	FILE              *handle;

	#define LINK_MAGIC_CHECK() {if (fread(&magic, sizeof(SLONG), 1, handle) != 1) goto file_error; ASSERT(magic == 12345678);}

	//
	// Initialise all data.
	//

	LINK_allocate_memory();

	//
	// Load in each file.
	//

	for (i = 0; i < num_object_files; i++)
	{
		//
		// Open the file.
		//

		handle = fopen(object_fname[i], "rb");

		if (handle == NULL)
		{
			//
			// ERROR! Can't open object file...
			//

			goto file_error;
		}

		//
		// Load in the header.
		//

		if (fread(&lh, sizeof(LINK_Header), 1, handle) != 1) goto file_error;

		//
		// Correct version number?
		//

		if (lh.version != 1)
		{
			//
			// ERROR!
			//
		}

		//
		// Get another LINK_File.
		//

		if (LINK_file_upto >= LINK_file_max)
		{
			LINK_file_max *= 2;
			LINK_file      = (LINK_File *) realloc(LINK_file, sizeof(LINK_File) * LINK_file_max);
		}

		lf = &LINK_file[LINK_file_upto++];

		//
		// Initialise.
		//

		memset(lf, 0, sizeof(LINK_File));

		//
		// Instructions.
		//

		lf->first_instruction = LINK_instruction_upto;
		lf->num_instructions  = lh.num_instructions;

		while(LINK_instruction_upto + lh.num_instructions > LINK_instruction_max)
		{
			LINK_instruction_max *= 2;
			LINK_instruction      = (SLONG *) realloc(LINK_instruction, sizeof(SLONG) * LINK_instruction_max);
		}

		if (fread(LINK_instruction + LINK_instruction_upto, sizeof(SLONG), lh.num_instructions, handle) != lh.num_instructions) goto file_error;

		LINK_instruction_upto += lh.num_instructions;

		LINK_MAGIC_CHECK();

		//
		// The data table.
		//

		lf->first_table_datum = LINK_table_data_upto;
		lf->num_table_data    = lh.data_table_length_in_bytes;

		while(LINK_table_data_upto + lh.data_table_length_in_bytes > LINK_table_data_max)
		{
			LINK_table_data_max *= 2;
			LINK_table_data      = (CBYTE *) realloc(LINK_table_data, sizeof(CBYTE) * LINK_table_data_max);
		}

		if (fread(LINK_table_data + LINK_table_data_upto, sizeof(CBYTE), lh.data_table_length_in_bytes, handle) != lh.data_table_length_in_bytes) goto file_error;

		LINK_table_data_upto += lh.data_table_length_in_bytes;

		LINK_MAGIC_CHECK();

		//
		// Globals.
		//

		lf->first_global = LINK_global_upto;
		lf->num_globals  = lh.num_globals;

		while(LINK_global_upto + lh.num_globals > LINK_global_max)
		{
			LINK_global_max *= 2;
			LINK_global      = (LINK_Global *) realloc(LINK_global, sizeof(LINK_Global) * LINK_global_max);
		}

		if (fread(LINK_global + LINK_global_upto, sizeof(LINK_Global), lh.num_globals, handle) != lh.num_globals) goto file_error;

		LINK_global_upto += lh.num_globals;

		LINK_MAGIC_CHECK();

		//
		// Functions.
		//

		lf->first_function = LINK_function_upto;
		lf->num_functions  = lh.num_functions;

		while(LINK_function_upto + lh.num_functions > LINK_function_max)
		{
			LINK_function_max *= 2;
			LINK_function      = (LINK_Function *) realloc(LINK_function, sizeof(LINK_Function) * LINK_function_max);
		}

		if (fread(LINK_function + LINK_function_upto, sizeof(LINK_Function), lh.num_functions, handle) != lh.num_functions) goto file_error;

		LINK_function_upto += lh.num_functions;

		LINK_MAGIC_CHECK();

		//
		// Lines.
		//

		lf->first_line = LINK_line_upto;
		lf->num_lines  = lh.num_lines;

		while(LINK_line_upto + lh.num_lines > LINK_line_max)
		{
			LINK_line_max *= 2;
			LINK_line      = (LINK_Line *) realloc(LINK_line, sizeof(LINK_Line) * LINK_line_max);
		}

		if (fread(LINK_line + LINK_line_upto, sizeof(LINK_Line), lh.num_lines, handle) != lh.num_lines) goto file_error;

		LINK_line_upto += lh.num_lines;

		LINK_MAGIC_CHECK();

		//
		// Jumps.
		//

		lf->first_jump = LINK_jump_upto;
		lf->num_jumps  = lh.num_jumps;

		while(LINK_jump_upto + lh.num_jumps > LINK_jump_max)
		{
			LINK_jump_max *= 2;
			LINK_jump      = (LINK_Jump *) realloc(LINK_jump, sizeof(LINK_Jump) * LINK_jump_max);
		}

		if (fread(LINK_jump + LINK_jump_upto, sizeof(LINK_Jump), lh.num_jumps, handle) != lh.num_jumps) goto file_error;

		LINK_jump_upto += lh.num_jumps;

		LINK_MAGIC_CHECK();

		//
		// Fields.
		//

		lf->first_field = LINK_field_upto;
		lf->num_fields  = lh.num_fields;

		while(LINK_field_upto + lh.num_fields > LINK_field_max)
		{
			LINK_field_max *= 2;
			LINK_field      = (LINK_Field *) realloc(LINK_field, sizeof(LINK_Field) * LINK_field_max);
		}

		if (fread(LINK_field + LINK_field_upto, sizeof(LINK_Field), lh.num_fields, handle) != lh.num_fields) goto file_error;

		LINK_field_upto += lh.num_fields;

		LINK_MAGIC_CHECK();

		//
		// Globalrefs.
		//

		lf->first_global_ref = LINK_global_ref_upto;
		lf->num_global_refs  = lh.num_global_refs;

		while(LINK_global_ref_upto + lh.num_global_refs > LINK_global_ref_max)
		{
			LINK_global_ref_max *= 2;
			LINK_global_ref      = (LINK_Globalref *) realloc(LINK_global_ref, sizeof(LINK_Globalref) * LINK_global_ref_max);
		}

		if (fread(LINK_global_ref + LINK_global_ref_upto, sizeof(LINK_Globalref), lh.num_global_refs, handle) != lh.num_global_refs) goto file_error;

		LINK_global_ref_upto += lh.num_global_refs;

		LINK_MAGIC_CHECK();

		//
		// Undefined function references.
		//

		lf->first_undef_ref = LINK_undef_ref_upto;
		lf->num_undef_refs  = lh.num_undef_refs;

		while(LINK_undef_ref_upto + lh.num_undef_refs > LINK_undef_ref_max)
		{
			LINK_undef_ref_max *= 2;
			LINK_undef_ref      = (LINK_Undefref *) realloc(LINK_undef_ref, sizeof(LINK_Undefref) * LINK_undef_ref_max);
		}

		if (fread(LINK_undef_ref + LINK_undef_ref_upto, sizeof(LINK_Undefref), lh.num_undef_refs, handle) != lh.num_undef_refs) goto file_error;

		LINK_undef_ref_upto += lh.num_undef_refs;

		LINK_MAGIC_CHECK();

		//
		// Fieldrefs.
		//

		lf->first_field_ref = LINK_field_ref_upto;
		lf->num_field_refs  = lh.num_field_refs;

		while(LINK_field_ref_upto + lh.num_field_refs > LINK_field_ref_max)
		{
			LINK_field_ref_max *= 2;
			LINK_field_ref      = (LINK_Fieldref *) realloc(LINK_field_ref, sizeof(LINK_Fieldref) * LINK_field_ref_max);
		}

		if (fread(LINK_field_ref + LINK_field_ref_upto, sizeof(LINK_Fieldref), lh.num_field_refs, handle) != lh.num_field_refs) goto file_error;

		LINK_field_ref_upto += lh.num_field_refs;

		LINK_MAGIC_CHECK();

		//
		// Data table refs.
		//

		lf->first_data_table_ref = LINK_data_table_ref_upto;
		lf->num_data_table_refs  = lh.num_data_table_refs;

		while(LINK_data_table_ref_upto + lh.num_data_table_refs > LINK_data_table_ref_max)
		{
			LINK_data_table_ref_max *= 2;
			LINK_data_table_ref      = (LINK_Datatableref *) realloc(LINK_data_table_ref, sizeof(LINK_Datatableref) * LINK_data_table_ref_max);
		}

		if (fread(LINK_data_table_ref + LINK_data_table_ref_upto, sizeof(LINK_Datatableref), lh.num_data_table_refs, handle) != lh.num_data_table_refs) goto file_error;

		LINK_data_table_ref_upto += lh.num_data_table_refs;

		LINK_MAGIC_CHECK();

		//
		// Load in the debug data.
		//

		lf->first_debug_datum = LINK_debug_data_upto;

		if (fread(&lf->num_debug_data, sizeof(SLONG), 1, handle) != 1) goto file_error;

		while(LINK_debug_data_upto + lf->num_debug_data > LINK_debug_data_max)
		{
			LINK_debug_data_max *= 2;
			LINK_debug_data      = (CBYTE *) realloc(LINK_debug_data, sizeof(CBYTE) * LINK_debug_data_max);
		}

		if (fread(LINK_debug_data + LINK_debug_data_upto, sizeof(CBYTE), lf->num_debug_data, handle) != lf->num_debug_data) goto file_error;

		LINK_debug_data_upto += lf->num_debug_data;

		//
		// Finished. We should have read the entire file.
		//

		#ifdef _DEBUG

		//
		// Make sure there is no file left!
		//

		{
			UBYTE junk[1024];
			SLONG read;

			read = fread(junk, 1, 1024, handle);

			ASSERT(read == 0);
		}

		#endif

		//
		// Finished reading the file.
		//

		fclose(handle);
	}

	//
	// Add all exported globals, fields and exported functions
	// to the symbol table. This helps us allocate global_ids
	// and field_ids and resolve calls to functions across files.
	//

	ST_clear_all();
	SYSVAR_init();

	LINK_global_id_upto = 0;
	LINK_field_id_upto  = SYSVAR_FIELD_NUMBER;

	for (i = 0; i < LINK_file_upto; i++)
	{
		lf = &LINK_file[i];

		//
		// Overwrite each global's index field with the new global_id.
		//

		for (j = 0; j < lf->num_globals; j++)
		{
			lg = &LINK_global[lf->first_global + j];

			if (lg->export)
			{
				ASSERT(WITHIN(lg->name + lf->first_debug_datum, 0, LINK_debug_data_upto - 1));

				//
				// Is this global already in the symbol table?
				//

				if (ST_find(LINK_debug_data + lg->name + lf->first_debug_datum))
				{
					//
					// ERROR! Multiply defined exported global.
					//

					ASSERT(0);
				}
				else
				{
					//
					// The global wasn't found. Allocate a new global_id and add
					// this global to the symbol table.
					//

					lg->index = LINK_global_id_upto++;

					ST_add(ST_TABLE_GLOBAL, LINK_debug_data + lg->name + lf->first_debug_datum, lg->index, 0);
				}
			}
			else
			{
				ASSERT(WITHIN(lg->name + lf->first_debug_datum, 0, LINK_debug_data_upto - 1));

				if (lg->local)
				{
					//
					// This global is local for sure, so it needs it's own ID.
					//

					lg->index = LINK_global_id_upto++;
				}
				else
				{
					//
					// Is this global already in the symbol table?
					//

					if (ST_find(LINK_debug_data + lg->name + lf->first_debug_datum))
					{
						//
						// Use the same global id.
						//

						lg->index = ST_found_value;
					}
					else
					{
						//
						// Allocate a new global_id.
						//

						lg->index = LINK_global_id_upto++;
					}
				}
			}
		}

		//
		// Overwrite each field's index field with the new field_id.
		//

		for (j = 0; j < lf->num_fields; j++)
		{	
			ld = &LINK_field[lf->first_field + j];

			ASSERT(WITHIN(ld->name + lf->first_debug_datum, 0, LINK_debug_data_upto - 1));

			//
			// Is this field already in the symbol table?
			//

			if (ST_find(LINK_debug_data + ld->name + lf->first_debug_datum))
			{
				//
				// Use the same field_id.
				//

				ld->index = ST_found_value;
			}
			else
			{
				//
				// Allocate a new field_id and add it to the symbol table.
				//

				ld->index = LINK_field_id_upto++;

				ST_add(ST_TABLE_GLOBAL, LINK_debug_data + ld->name + lf->first_debug_datum, ld->index, 0);
			}
		}

		//
		// Add all the exported functions to the symbol table.
		//

		for (j = 0; j < lf->num_functions; j++)
		{
			lc = &LINK_function[lf->first_function + j];

			if (lc->export)
			{
				ASSERT(WITHIN(lc->name + lf->first_debug_datum, 0, LINK_debug_data_upto - 1));

				//
				// The value associated with the function is the first instruction
				// of the function body.
				//

				if (ST_find(LINK_debug_data + lc->name + lf->first_debug_datum))
				{
					//
					// ERROR! Multiply defined function!
					//

					ASSERT(0);
				}
				else
				{
					//
					// What is the first instruction of the function body?
					//

					ASSERT(WITHIN(lc->line_start, 0, lf->num_lines - 1));
					ASSERT(WITHIN(lc->line_start + lf->first_line, 0, LINK_line_upto - 1));

					instruction = LINK_line[lf->first_line + lc->line_start].instruction;

					ASSERT(WITHIN(instruction, 0, lf->num_instructions - 1));

					instruction += lf->first_instruction;

					ASSERT(WITHIN(instruction, 0, LINK_instruction_upto - 1));
				
					//
					// The first two instructions of a function are a GOTO to the
					// end of the funciton. This is so that execution will jump
					// over the function instead of leaking into it accidentally.
					//

					instruction += 2;

					//
					// Add the function to the symbol table.
					//

					ST_add(
						ST_TABLE_GLOBAL,
						LINK_debug_data + lc->name + lf->first_debug_datum,
						instruction,
						0);
				}
			}
		}
	}

	//
	// Do the actual linking.
	//

	for (i = 0; i < LINK_file_upto; i++)
	{
		lf = &LINK_file[i];

		//
		// Fix instructions that refer to globals.
		//

		for (j = 0; j < lf->num_global_refs; j++)
		{
			ASSERT(WITHIN(lf->first_global_ref + j, 0, LINK_global_ref_upto - 1));

			instruction  = LINK_global_ref[lf->first_global_ref + j].instruction;
			instruction += lf->first_instruction;

			ASSERT(WITHIN(instruction, 0, LINK_instruction_upto - 1));

			//
			// We have the instruction that contains the old global_id.
			// Overwrite it with the new one.
			//

			ASSERT(WITHIN(LINK_instruction[instruction], 0, lf->num_globals - 1));

			LINK_instruction[instruction] = LINK_global[lf->first_global + LINK_instruction[instruction]].index;
		}

		//
		// Fix instructions that refer to fields.
		//

		for (j = 0; j < lf->num_field_refs; j++)
		{
			ASSERT(WITHIN(lf->first_field_ref + j, 0, LINK_field_ref_upto - 1));

			instruction  = LINK_field_ref[lf->first_field_ref + j].instruction;
			instruction += lf->first_instruction;

			ASSERT(WITHIN(instruction, 0, LINK_instruction_upto - 1));

			//
			// We have the instruction that contains the old field_id.
			// Overwrite it with the new one.
			//

			ASSERT(WITHIN(LINK_instruction[instruction], 0, lf->num_fields - 1));

			LINK_instruction[instruction] = LINK_field[lf->first_field + LINK_instruction[instruction]].index;
		}

		//
		// Fix calls to functions across files.
		//

		for (j = 0; j < lf->num_undef_refs; j++)
		{
			ASSERT(WITHIN(lf->first_undef_ref + j, 0, LINK_undef_ref_upto - 1));

			lu = &LINK_undef_ref[lf->first_undef_ref + j];

			//
			// Look for this undefined function in the symbol table.
			//

			ASSERT(WITHIN(lu->name + lf->first_debug_datum, 0, LINK_debug_data_upto - 1));

			if (!ST_find(LINK_debug_data + lu->name + lf->first_debug_datum))
			{
				//
				// ERROR! Undefined function.
				//

				ASSERT(0);
			}
			else
			{
				//
				// Write the address of the function into the instructions.
				//

				ASSERT(WITHIN(lu->instruction, 0, lf->num_instructions - 1));
				ASSERT(WITHIN(lf->first_instruction + lu->instruction, 0, LINK_instruction_upto - 1));
				ASSERT(WITHIN(ST_found_value, 0, LINK_instruction_upto - 1));

				LINK_instruction[lf->first_instruction + lu->instruction] = ST_found_value;
			}
		}

		//
		// Fix jumps.
		//

		for (j = 0; j < lf->num_jumps; j++)
		{
			ASSERT(WITHIN(lf->first_jump + j, 0, LINK_jump_upto - 1));
			
			lj = &LINK_jump[lf->first_jump + j];

			ASSERT(WITHIN(lj->instruction, 0, lf->num_instructions - 1));
			ASSERT(WITHIN(lj->instruction + lf->first_instruction, 0, LINK_instruction_upto - 1));

			LINK_instruction[lf->first_instruction + lj->instruction] += lf->first_instruction;
		}

		//
		// Fix references into the data table.
		//

		for (j = 0; j < lf->num_data_table_refs; j++)
		{
			ASSERT(WITHIN(lf->first_data_table_ref + j, 0, LINK_data_table_ref_upto - 1));

			lt = &LINK_data_table_ref[lf->first_data_table_ref + j];

			ASSERT(WITHIN(lt->instruction, 0, lf->num_instructions - 1));
			ASSERT(WITHIN(lt->instruction + lf->first_instruction, 0, LINK_instruction_upto - 1));
			ASSERT(WITHIN(LINK_instruction[lt->instruction + lf->first_instruction], 0, lf->num_table_data - 1));

			LINK_instruction[lt->instruction + lf->first_instruction] += lf->first_table_datum;

			ASSERT(WITHIN(LINK_instruction[lt->instruction + lf->first_instruction], 0, LINK_table_data_upto - 1));
		}

		//
		// The last instruction of any file is an EXIT. Replace all these
		// EXIT instrucitons with NOPs except for the last one.
		//

		if (i == LINK_file_upto - 1)
		{
			//
			// This is the last file.
			//
		}
		else
		{
			ASSERT(WITHIN(lf->first_instruction + lf->num_instructions - 1, 0, LINK_instruction_upto - 1));
			ASSERT(LINK_instruction[lf->first_instruction + lf->num_instructions - 1] == ML_DO_EXIT);

			LINK_instruction[lf->first_instruction + lf->num_instructions - 1] = ML_DO_NOP;
		}
	}

	//
	// Ready to write out the executable now. Create the
	// header of an executable.
	//

	ML_Header mh;

	mh.version                      = ML_VERSION_NUMBER;
	mh.instructions_memory_in_bytes = LINK_instruction_upto * sizeof(SLONG);
	mh.data_table_length_in_bytes   = LINK_table_data_upto;
	mh.num_globals                  = LINK_global_upto;

	//
	// Open the executable file.
	//

	handle = fopen(exec_fname, "wb");

	if (handle == NULL)
	{
		//
		// ERROR!
		//

		goto file_error;
	}

	if (fwrite(&mh, sizeof(mh), 1, handle) != 1) goto file_error;

	//
	// The instructions.
	//

	if (fwrite(LINK_instruction, sizeof(SLONG), LINK_instruction_upto, handle) != LINK_instruction_upto) goto file_error;

	//
	// The string table.
	//

	if (fwrite(LINK_table_data, sizeof(UBYTE), LINK_table_data_upto, handle) != LINK_table_data_upto) goto file_error;

	fclose(handle);

	//
	// All done.
	//

	LINK_free_memory();

	return TRUE;

  file_error:;

	//
	// ERROR!
	//

	if (handle)
	{
		fclose(handle);
	}

	LINK_free_memory();

	return FALSE;
}