#include "flags.h"

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "defines.h"

#include "include.h"

#include "listfile.h"

#include "phase_3.h"

#include "phase_4.h"

#include "parse.h"

#include "stack.h"

#include "printf.h"

#include "main.h"

extern struct section_def *g_sections_first, *g_sections_last, *g_sec_tmp, *g_sec_next;

extern struct incbin_file_data *g_incbin_file_data_first, *g_ifd_tmp;

extern struct export_def *g_export_first, *g_export_last;

extern struct label_def *g_label_tmp, *g_label_last, *g_labels;

extern struct map_t *g_defines_map, *g_namespace_map, *g_global_unique_label_map;

extern struct file_name_info *g_file_name_info_first;

extern struct slot g_slots[256];

extern struct after_section *g_after_sections;

extern struct label_sizeof *g_label_sizeofs;

extern struct assertion *g_assertions_first;

extern struct label_context g_label_context, *g_label_context_first, *g_label_context_last;

extern FILE *g_file_out_ptr;

extern unsigned char *g_rom_banks, *g_rom_banks_usage_table;

extern char *g_tmp, *g_final_name;

extern int g_rombanks, g_output_format, g_test_mode, g_listfile_data, g_little_endian, g_sizeof_g_tmp;

extern int g_label_context_running_number, g_continued_parsing_after_an_error, g_romheader_baseaddress;

#if defined(GB)

extern char g_licenseecodenew_c1, g_licenseecodenew_c2;

extern int g_computechecksum_defined, g_computecomplementcheck_defined;

extern int g_cartridgetype;

extern int g_name_defined, g_computechecksum_defined, g_computecomplementcheck_defined;

extern int g_licenseecodeold_defined, g_licenseecodenew_defined;

extern int g_licenseecodeold, g_romgbc;

#endif

extern int g_romtype, g_rambanks, g_emptyfill, g_max_address;

extern int g_rambanks_defined, g_verbose_level;

extern int g_section_status;

extern int g_banksize, g_banksize_defined;

extern int g_slots_amount;

extern int *g_banks, *g_bankaddress, g_rombankmap_defined;

extern int g_latest_stack, g_last_stack_id;

extern int g_bankheader_status;

extern int g_smc_defined, g_makefile_rules;

#if defined(W65816)

extern int g_lorom_defined, g_hirom_defined, g_slowrom_defined, g_fastrom_defined, g_snes_mode, g_exhirom_defined;

extern int g_computesneschecksum_defined, g_sramsize, g_sramsize_defined, g_exlorom_defined;

#endif

#if defined(Z80)

extern int g_computesmschecksum_defined, g_smstag_defined, g_smsheader_defined, g_smsforcechecksum_defined;

extern int g_smschecksumsize_defined, g_smschecksumsize;

#endif

#if defined(MC68000)

extern int g_computesmdchecksum_defined, g_smdheader_defined;

extern int g_mdvectors_defined, g_mcdheader_defined;

#endif

struct label_def *g_unknown_labels = NULL, *g_unknown_labels_last = NULL;

struct label_def *g_unknown_header_labels = NULL, *g_unknown_header_labels_last = NULL;

char g_mem_insert_action[MAX_NAME_LENGTH * 3 + 1024], g_namespace[MAX_NAME_LENGTH + 1];

static int s_pc_bank = 0, s_pc_full = 0, s_rom_bank, s_mem_insert_overwrite, s_slot = 0, s_base = 0, s_pc_slot, s_pc_slot_max;

static int s_filename_id, s_line_number, s_dstruct_start = -1, s_special_id = 0, s_base_backup = -1;

static struct after_section *s_after_tmp;

static struct label_sizeof *s_label_sizeof_tmp;

#define WRITEOUT_OV fprintf(final_ptr, "%c%c%c%c", (ov>>24)&0xFF, (ov>>16)&0xFF, (ov>>8)&0xFF, ov&0xFF);

#define WRITEOUT_DOU { \

cp = (unsigned char *)&dou; \

fprintf(final_ptr, "%c%c%c%c%c%c%c%c", cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); \

}

#define XSTRINGIFY(x) #x

#define STRINGIFY(x) XSTRINGIFY(x)

#define STRING_READ_FORMAT ("%" STRINGIFY(MAX_NAME_LENGTH) "s ")

static void _write_stack_items(FILE *final_ptr, struct stack *stack) {

unsigned char *cp;

double dou;

int ind;

for (ind = 0; ind < stack->stacksize; ind++) {

fprintf(final_ptr, "%c%c", stack->stack_items[ind].type, stack->stack_items[ind].sign);

if (stack->stack_items[ind].type == STACK_ITEM_TYPE_LABEL || stack->stack_items[ind].type == STACK_ITEM_TYPE_STRING)

fprintf(final_ptr, "%s%c", stack->stack_items[ind].string, 0);

else {

dou = stack->stack_items[ind].value;

WRITEOUT_DOU;

}

}

}

static int _write_assertions(FILE *final_ptr, int include_slot_bank_base) {

struct assertion *assertion;

int ov;

ov = 0;

assertion = g_assertions_first;

while (assertion != NULL) {

ov++;

assertion = assertion->next;

}

WRITEOUT_OV;

assertion = g_assertions_first;

while (assertion != NULL) {

struct stack *stack = assertion->stack;

fprintf(final_ptr, "%c%s%c", assertion->action, assertion->message, 0);

ov = stack->id;

WRITEOUT_OV;

fprintf(final_ptr, "%c", STACK_TYPE_ASSERT);

ov = stack->section_id;

WRITEOUT_OV;

ov = stack->filename_id;

WRITEOUT_OV;

fprintf(final_ptr, "%c%c", stack->stacksize, stack->position);

if (include_slot_bank_base == YES)

fprintf(final_ptr, "%c", stack->slot);

ov = stack->address;

WRITEOUT_OV;

ov = stack->linenumber;

WRITEOUT_OV;

if (include_slot_bank_base == YES) {

ov = stack->bank;

WRITEOUT_OV;

ov = stack->base;

WRITEOUT_OV;

}

_write_stack_items(final_ptr, stack);

assertion = assertion->next;

}

return SUCCEEDED;

}

static int _print_fscanf_error_accessing_internal_data_stream(int file_name_id, int line_number) {

print_text(NO, "%s:%d: INTERNAL_PHASE_2: Could not read enough elements from the internal data stream. Please submit a bug report!\n",

get_file_name(file_name_id), line_number);

return FAILED;

}

static int _try_to_calculate_stack_calculation_define(struct definition *definition) {

struct stack *stack = find_stack_calculation((int)definition->value, YES);

if (stack == NULL)

return FAILED;

if (stack->is_function_body == NO && resolve_stack(stack->stack_items, stack->stacksize) == SUCCEEDED) {

double r;

if (compute_stack(stack, stack->stacksize, &r) == FAILED)

return FAILED;

/* HACK: mark it to be function body so it won't get exported */

stack->is_function_body = YES;

/* calculation succeeded -> turn the define into a value define */

definition->type = DEFINITION_TYPE_VALUE;

definition->value = r;

}

return SUCCEEDED;

}

static struct label_def *_new_unknown_reference(int type) {

struct label_def *label;

int n = 0, j = 0;

if ((is_label_anonymous(g_tmp) == YES || g_tmp[0] == '_' || strcmp(g_tmp, "_b") == 0 || strcmp(g_tmp, "_f") == 0) && g_label_context_last->isolated_macro != NULL) {

if (add_context_to_anonymous_label(g_tmp, g_sizeof_g_tmp, g_label_context_last, s_filename_id, s_line_number) == FAILED)

return NULL;

}

if (g_tmp[0] == ':')

j = 1;

while (n < 10 && g_tmp[n+j] == '@')

n++;

n--;

while (n >= 0 && g_label_context_last->parent_labels[n] == NULL)

n--;

if (n >= 0) {

if (mangle_label(&g_tmp[j], g_label_context_last->parent_labels[n]->label, n, MAX_NAME_LENGTH-j, s_filename_id, s_line_number) == FAILED)

return NULL;

}

label = calloc(1, sizeof(struct label_def));

if (label == NULL) {

print_text(NO, "%s:%d: _NEW_UNKNOWN_REFERENCE: Out of memory.\n", get_file_name(s_filename_id), s_line_number);

return NULL;

}

label->symbol = NO;

strcpy(label->label, g_tmp);

label->next = NULL;

label->type = type;

label->filename_id = s_filename_id;

label->linenumber = s_line_number;

label->section_status = g_section_status;

if (g_section_status == ON) {

label->section_id = g_sec_tmp->id;

label->section_struct = g_sec_tmp;

/* relative address, to the beginning of the section */

label->address = g_sec_tmp->i;

label->base = s_base;

label->bank = g_sec_tmp->bank;

label->slot = g_sec_tmp->slot;

}

else {

label->section_id = 0;

label->section_struct = NULL;

/* bank address, in ROM memory */

label->address = s_pc_bank;

label->base = s_base;

label->bank = s_rom_bank;

label->slot = s_slot;

}

label->special_id = s_special_id;

label->bits_position = 0;

label->bits_to_define = 0;

/* outside bank header section */

if (g_bankheader_status == OFF) {

if (g_unknown_labels_last == NULL) {

g_unknown_labels = label;

g_unknown_labels_last = label;

}

else {

g_unknown_labels_last->next = label;

g_unknown_labels_last = label;

}

}

/* bank header section */

else {

if (label->label[0] == '_') {

print_text(NO, "%s:%d: _NEW_UNKNOWN_REFERENCE: Referring to a local label (\"%s\") from inside a bank header section is not allowed.\n",

get_file_name(s_filename_id), s_line_number, label->label);

return NULL;

}

if (g_unknown_header_labels_last == NULL) {

g_unknown_header_labels = label;

g_unknown_header_labels_last = label;

}

else {

g_unknown_header_labels_last->next = label;

g_unknown_header_labels_last = label;

}

}

return label;

}

static int _mangle_stack_references(struct stack *stack) {

int ind, n, j;

char *s;

for (ind = 0; ind < stack->stacksize; ind++) {

if (stack->stack_items[ind].type == STACK_ITEM_TYPE_LABEL) {

n = 0;

j = 0;

if (stack->stack_items[ind].string[0] == ':')

j = 1;

while (n < 10 && stack->stack_items[ind].string[n+j] == '@')

n++;

n--;

while (n >= 0 && g_label_context_last->parent_labels[n] == NULL)

n--;

if (n >= 0) {

if (mangle_label(&stack->stack_items[ind].string[j], g_label_context_last->parent_labels[n]->label, n, MAX_NAME_LENGTH-j, s_filename_id, s_line_number) == FAILED)

return FAILED;

}

/* add current ISOLATED .MACRO context? */

s = stack->stack_items[ind].string;

if ((is_label_anonymous(s) == YES || s[0] == '_' || strcmp(s, "_b") == 0 || strcmp(s, "_f") == 0) && g_label_context_last->isolated_macro != NULL) {

if (add_context_to_anonymous_label(s, sizeof(stack->stack_items[ind].string), g_label_context_last, s_filename_id, s_line_number) == FAILED)

return FAILED;

}

}

}

return SUCCEEDED;

}

static int _namespaced_label_is_in_this_file(char *name) {

struct label_def *l;

/* label in a (section) namespace? */

if (g_section_status == ON && g_sec_tmp != NULL && g_sec_tmp->nspace != NULL) {

if (hashmap_get(g_sec_tmp->nspace->label_map, name, (void*)&l) == MAP_OK) {

if (s_filename_id == l->filename_id)

return YES;

}

}

/* global label? */

if (hashmap_get(g_global_unique_label_map, name, (void*)&l) == MAP_OK) {

if (s_filename_id == l->filename_id)

return YES;

}

return NO;

}

static int _add_namespace_to_reference(char *label, char *name_space, unsigned int label_size) {

char expanded[MAX_NAME_LENGTH*2+2];

snprintf(expanded, sizeof(expanded), "%s.%s", name_space, label);

if (strlen(expanded) >= label_size) {

print_text(NO, "_ADD_NAMESPACE_TO_REFERENCE: Label expands to \"%s\" which is %d characters too large.\n", expanded, (int)(strlen(expanded)-label_size+1));

return FAILED;

}

/* use the expanded version only if we can find it */

if (_namespaced_label_is_in_this_file(expanded) == YES) {

strcpy(label, expanded);

return SUCCEEDED;

}

/* wlalink builds _sizeof_* from the label's final name, so it does not exist

yet. A naked "_sizeof_baz" in namespace "foo" has to become "_sizeof_foo.baz"

when "foo.baz" is a label in this file. Leave assembler-made _sizeof_*

definitions (enum, struct, ramsection) untouched. */

if (strncmp(label, "_sizeof_", 8) == 0) {

struct definition *tmp_def;

char base_expanded[MAX_NAME_LENGTH*2+2];

hashmap_get(g_defines_map, label, (void*)&tmp_def);

if (tmp_def != NULL)

return SUCCEEDED;

snprintf(base_expanded, sizeof(base_expanded), "%s.%s", name_space, &label[8]);

if (_namespaced_label_is_in_this_file(base_expanded) == NO)

return SUCCEEDED;

snprintf(expanded, sizeof(expanded), "_sizeof_%s", base_expanded);

if (strlen(expanded) >= label_size) {

print_text(NO, "_ADD_NAMESPACE_TO_REFERENCE: Label expands to \"%s\" which is %d characters too large.\n", expanded, (int)(strlen(expanded)-label_size+1));

return FAILED;

}

strcpy(label, expanded);

}

return SUCCEEDED;

}

static int _add_namespace_to_stack_references(struct stack *st, char *name_space) {

int j;

for (j = 0; j < st->stacksize; j++) {

if (st->stack_items[j].type == STACK_ITEM_TYPE_LABEL) {

if (is_label_anonymous(st->stack_items[j].string) == YES)

continue;

if (_add_namespace_to_reference(st->stack_items[j].string, name_space, sizeof(st->stack_items[j].string)) == FAILED)

return FAILED;

}

}

return SUCCEEDED;

}

static void _bits_add_bit(int *bits_byte, int *bits_position, int *bits_to_define, int data) {

int bit = (data >> (*bits_to_define - 1)) & 1;

*bits_to_define = *bits_to_define - 1;

*bits_byte = *bits_byte | (bit << (7 - *bits_position));

*bits_position = *bits_position + 1;

}

static int _cp1610_stack_has_label(struct stack *stack) {

int i;

for (i = 0; i < stack->stacksize; i++) {

if (stack->stack_items[i].type == STACK_ITEM_TYPE_LABEL)

return YES;

}

return NO;

}

static int _cp1610_mem_insert_word(int word) {

if (g_little_endian == YES) {

if (mem_insert(word & 0xFF) == FAILED)

return FAILED;

if (mem_insert((word >> 8) & 0xFF) == FAILED)

return FAILED;

}

else {

if (mem_insert((word >> 8) & 0xFF) == FAILED)

return FAILED;

if (mem_insert(word & 0xFF) == FAILED)

return FAILED;

}

return SUCCEEDED;

}

int phase_4(void) {

int i, o, z, y, add_old = 0, x, q, inz, ind, bits_position = 0, bits_byte = 0, flip_endianess = NO, err;

char *t, c, tmp_buffer[MAX_NAME_LENGTH + 1];

struct stack *stack;

struct definition *tmp_def;

/* initialize label context */

g_label_context.isolated_macro = NULL;

g_label_context.next = NULL;

g_label_context.prev = NULL;

for (x = 0; x < 10; x++)

g_label_context.parent_labels[x] = NULL;

g_label_context_last = &g_label_context;

g_label_context_first = &g_label_context;

g_label_context_running_number = 0;

g_namespace[0] = 0;

g_section_status = OFF;

g_bankheader_status = OFF;

s_mem_insert_overwrite = OFF;

if (g_verbose_level >= 100)

print_text(YES, "Internal pass 2...\n");

#if defined(MC68000)

if (g_mdvectors_defined == YES && g_smdheader_defined == NO)

print_text(NO, "WARNING: .MDVECTORS was used without .SMDHEADER; Mega Drive cartridge ROMs should also define .SMDHEADER.\n");

if (g_mcdheader_defined == YES && g_smdheader_defined == YES)

print_text(NO, "WARNING: .MCDHEADER and .SMDHEADER describe different Mega Drive boot layouts; use .MCDHEADER for Sega CD images and .SMDHEADER for cartridge ROMs.\n");

#endif

/* rewind to the beginning of the internal data stream */

fseek(g_file_out_ptr, 0, SEEK_SET);

while (fread(&c, 1, 1, g_file_out_ptr) != 0) {

switch (c) {

/* SPECIAL CASE ID */

case 'v':

err = fscanf(g_file_out_ptr, "%d ", &s_special_id);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

continue;

case 'E':

continue;

case 'j':

continue;

case 'J':

continue;

case 'i':

err = fscanf(g_file_out_ptr, "%d %s ", &inz, tmp_buffer);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

if (process_macro_in(inz, tmp_buffer, s_filename_id, s_line_number) == FAILED)

return FAILED;

continue;

case 'I':

err = fscanf(g_file_out_ptr, "%d %s ", &inz, tmp_buffer);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

if (process_macro_out(inz, tmp_buffer, s_filename_id, s_line_number) == FAILED)

return FAILED;

continue;

case 'g':

err = fscanf(g_file_out_ptr, "%*s ");

if (err < 0)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

continue;

case 'G':

continue;

case 'f':

err = fscanf(g_file_out_ptr, "%d ", &s_filename_id);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

continue;

case 'k':

err = fscanf(g_file_out_ptr, "%d ", &s_line_number);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

continue;

case 't':

err = fscanf(g_file_out_ptr, "%d ", &inz);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

if (inz == 0)

g_namespace[0] = 0;

else {

err = fscanf(g_file_out_ptr, STRING_READ_FORMAT, g_namespace);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

}

continue;

/* ASSERTION STACK CONTEXT */

case '~':

err = fscanf(g_file_out_ptr, "%d ", &inz);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

stack = find_stack_calculation(inz, NO);

if (stack == NULL) {

print_text(NO, "%s:%d: INTERNAL_PHASE_2: Could not find assertion stack number %d. WLA corruption detected. Please send a bug report!\n", get_file_name(s_filename_id), s_line_number, inz);

return FAILED;

}

if (stack->section_status == ON) {

stack->address = g_sec_tmp->i;

stack->base = s_base;

stack->bank = g_sec_tmp->bank;

stack->slot = g_sec_tmp->slot;

}

else {

stack->address = s_pc_bank;

stack->base = s_base;

stack->bank = s_rom_bank;

stack->slot = s_slot;

}

if (_mangle_stack_references(stack) == FAILED)

return FAILED;

if (g_namespace[0] != 0) {

if (g_section_status == OFF || g_sec_tmp->nspace == NULL) {

if (_add_namespace_to_stack_references(stack, g_namespace) == FAILED)

return FAILED;

}

}

continue;

/* SECTION */

case 'A':

case 'S':

if (c == 'A') {

err = fscanf(g_file_out_ptr, "%d %d ", &x, &ind);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

inz = YES;

}

else {

err = fscanf(g_file_out_ptr, "%d ", &x);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

inz = NO;

ind = 0x123456;

}

add_old = s_pc_bank;

g_sec_tmp = g_sections_first;

while (g_sec_tmp != NULL) {

if (g_sec_tmp->id == x)

break;

g_sec_tmp = g_sec_tmp->next;

}

/* skip all dead sections */

if (g_sec_tmp->alive == NO)

continue;

if (g_sec_tmp->base >= 0) {

s_base_backup = s_base;

s_base = g_sec_tmp->base;

}

if (c == 'A') {

if (inz == NO) {

/* sanity check */

print_text(NO, "%s: INTERNAL_PHASE_2: ind has not been set, but we use its value! Please submit a bug report!\n", get_file_name(s_filename_id));

return FAILED;

}

g_sec_tmp->address = ind;

}

ind = 0;

if (g_sec_tmp->maxsize_status == ON) {

if (g_sec_tmp->maxsize < g_sec_tmp->size) {

print_text(NO, "%s: INTERNAL_PHASE_2: Section \"%s\" (size %d) doesn't fit into the specified %d bytes.\n",

get_file_name(s_filename_id), g_sec_tmp->name, g_sec_tmp->size, g_sec_tmp->maxsize);

return FAILED;

}

else if (g_sec_tmp->size < g_sec_tmp->maxsize) {

g_sec_tmp->size = g_sec_tmp->maxsize;

ind = 1;

}

}

if (g_sec_tmp->size > 0) {

g_sec_tmp->data = calloc(sizeof(unsigned char) * g_sec_tmp->size, 1);

if (g_sec_tmp->data == NULL) {

print_text(NO, "%s:%d: INTERNAL_PHASE_2: Out of memory when trying to allocate room for section \"%s\".\n",

get_file_name(s_filename_id), s_line_number, g_sec_tmp->name);

return FAILED;

}

/* fill the padded area with _emptyfill_ */

if (ind == 1)

memset(g_sec_tmp->data, g_emptyfill, g_sec_tmp->size);

}

else

g_sec_tmp->data = NULL;

if (g_sec_tmp->name[0] == 'B' && strcmp(g_sec_tmp->name, "BANKHEADER") == 0)

g_bankheader_status = ON;

g_sec_tmp->i = 0;

g_section_status = ON;

continue;

/* ENDS */

case 's':

g_section_status = OFF;

g_bankheader_status = OFF;

if (s_base_backup >= 0) {

s_base = s_base_backup;

s_base_backup = -1;

}

/* some sections don't affect the ORG outside of them */

if (g_sec_tmp->advance_org == NO) {

s_pc_bank = add_old;

s_pc_full = g_bankaddress[s_rom_bank] + s_pc_bank;

s_pc_slot = g_slots[s_slot].address + s_pc_bank;

s_pc_slot_max = g_slots[s_slot].address + g_slots[s_slot].size;

}

continue;

/* DSB & DSW & DSL */

/* ('o' skips over memory without claiming it) */

case 'x':

case 'o':

err = fscanf(g_file_out_ptr, "%d %d ", &ind, &x);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing .DSB data", get_file_name(s_filename_id), s_line_number);

if (ind < 0) { /* going backward */

if (g_section_status == ON)

g_sec_tmp->i += ind;

s_pc_bank += ind;

s_pc_full += ind;

s_pc_slot += ind;

ind++;

}

else {

while (ind > 0) {

if (c == 'o') {

if (g_section_status == ON)

g_sec_tmp->i++;

s_pc_bank++;

s_pc_full++;

s_pc_slot++;

}

else {

if (mem_insert(x) == FAILED)

return FAILED;

}

ind--;

}

}

continue;

case 'X':

err = fscanf(g_file_out_ptr, "%d %d ", &ind, &inz);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

i = inz & 0xFF;

inz = (inz >> 8) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing .DSW data", get_file_name(s_filename_id), s_line_number);

while (ind > 0) {

if (g_little_endian == YES) {

if (mem_insert(i) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(i) == FAILED)

return FAILED;

}

ind--;

}

continue;

case 'h':

err = fscanf(g_file_out_ptr, "%d %d ", &ind, &inz);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

x = inz & 0xFF;

i = (inz >> 8) & 0xFF;

inz = (inz >> 16) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing .DSL data", get_file_name(s_filename_id), s_line_number);

while (ind > 0) {

if (g_little_endian == YES) {

if (mem_insert(x) == FAILED)

return FAILED;

if (mem_insert(i) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(i) == FAILED)

return FAILED;

if (mem_insert(x) == FAILED)

return FAILED;

}

ind--;

}

continue;

case 'w':

err = fscanf(g_file_out_ptr, "%d %d ", &ind, &inz);

if (err < 2)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

x = inz & 0xFF;

i = (inz >> 8) & 0xFF;

q = (inz >> 16) & 0xFF;

inz = (inz >> 24) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing .DSD data", get_file_name(s_filename_id), s_line_number);

while (ind > 0) {

if (g_little_endian == YES) {

if (mem_insert(x) == FAILED)

return FAILED;

if (mem_insert(i) == FAILED)

return FAILED;

if (mem_insert(q) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(q) == FAILED)

return FAILED;

if (mem_insert(i) == FAILED)

return FAILED;

if (mem_insert(x) == FAILED)

return FAILED;

}

ind--;

}

continue;

/* DATA & OPTCODE */

case 'd':

err = fscanf(g_file_out_ptr, "%d ", &x);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing a byte", get_file_name(s_filename_id), s_line_number);

if (mem_insert(x) == FAILED)

return FAILED;

continue;

case 'y':

err = fscanf(g_file_out_ptr, "%d ", &inz);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

x = inz & 0xFF;

inz = (inz >> 8) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing two bytes", get_file_name(s_filename_id), s_line_number);

if (g_little_endian == YES) {

if (mem_insert(x) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(x) == FAILED)

return FAILED;

}

continue;

case 'b':

err = fscanf(g_file_out_ptr, "%d ", &s_base);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

continue;

case 'z':

err = fscanf(g_file_out_ptr, "%d ", &inz);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

x = inz & 0xFF;

ind = (inz >> 8) & 0xFF;

inz = (inz >> 16) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing three bytes", get_file_name(s_filename_id), s_line_number);

if (g_little_endian == YES) {

if (mem_insert(x) == FAILED)

return FAILED;

if (mem_insert(ind) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(ind) == FAILED)

return FAILED;

if (mem_insert(x) == FAILED)

return FAILED;

}

continue;

case 'u':

err = fscanf(g_file_out_ptr, "%d ", &inz);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

x = inz & 0xFF;

q = (inz >> 8) & 0xFF;

ind = (inz >> 16) & 0xFF;

inz = (inz >> 24) & 0xFF;

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing four bytes", get_file_name(s_filename_id), s_line_number);

if (g_little_endian == YES) {

if (mem_insert(x) == FAILED)

return FAILED;

if (mem_insert(q) == FAILED)

return FAILED;

if (mem_insert(ind) == FAILED)

return FAILED;

if (mem_insert(inz) == FAILED)

return FAILED;

}

else {

if (mem_insert(inz) == FAILED)

return FAILED;

if (mem_insert(ind) == FAILED)

return FAILED;

if (mem_insert(q) == FAILED)

return FAILED;

if (mem_insert(x) == FAILED)

return FAILED;

}

continue;

/* BITS */

case '+':

{

int bits_to_define;

char type;

err = fscanf(g_file_out_ptr, "%d ", &bits_to_define);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

if (bits_to_define == 999) {

/* add the last byte if there is any data in it */

/* create a what-we-are-doing message for mem_insert*() warnings/errors */

snprintf(g_mem_insert_action, sizeof(g_mem_insert_action), "%s:%d: Writing .BITS' bits", get_file_name(s_filename_id), s_line_number);

if (bits_position > 0) {

if (mem_insert(bits_byte) == FAILED)

return FAILED;

}

bits_byte = 0;

bits_position = 0;

continue;

}

err = fscanf(g_file_out_ptr, "%c", &type);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);

if (type == 'a') {

int data;

err = fscanf(g_file_out_ptr, "%d", &data);

if (err < 1)

return _print_fscanf_error_accessing_internal_data_stream(s_filename_id, s_line_number);