Instruction Class Reference

linked list member holding instruction data More...

#include <instructions.h>

Public Member Functions
Instruction *	instruction_load (char *fname)
	Load instruction data from CSV file. More...
Instruction *	instruction_find (Instruction *list, char *mnem)
	find the Instruction entry for a given mnemonic More...
void	instruction_free (Instruction *list)
	free all memory associated with an Instruction* list More...
void	instruction_print (Instruction *instr)
	fancy-print one instruction data More...
void	instruction_print_all (Instruction *list)
	debug-print all instructions in a list More...

Data Fields
char	mnem [4]
	3-letter mnemonic of an instruction + trailing 0 More...
unsigned char	opcs [ADRM_COUNT]
	Different combinarions of this instruction. Invalid ones are set to OPC_INVALID. More...
struct Instruction *	next
	Next instruction pointer on NULL. More...

Detailed Description

linked list member holding instruction data

Member of a list which holds data about instructions and opcodes.
This list should be loaded from file using instruction_load()

Definition at line 25 of file instructions.h.

Member Function Documentation

instruction_find()

Instruction * instruction_find	(	Instruction *	list,
		char *	mnem
	)

find the Instruction entry for a given mnemonic

Parameters

list	linked list head containing loaded instructions
mnem	pointer to string to seatch for

Returns

instruction list entry or NULL if not found

Searches the linked list for an instruction entry.
Only checks the first 3 characters, so there is no need to copy the data on the caller side.

Definition at line 111 of file instructions.c.

                                                             {
    Instruction* ptr;
    for (ptr = list; ptr != NULL; ptr = ptr->next) {
        if (util_match_string(mnem, ptr->mnem, 3) == 0)
            return ptr;
    }
    return NULL;
}

Referenced by Token::token_link_instruction().

instruction_free()

void instruction_free

(

Instruction *

list

)

free all memory associated with an Instruction* list

Parameters

list	list to free

Frees all memory associated with the instruction data linked list, including the list head.
Invalidates all pointers to any data within the list, so they should be all NULL-ed!

Definition at line 121 of file instructions.c.

                                         {
    if (!list) return;
    while (list->next != NULL) {
        Instruction* ptr = list->next;
        list->next = ptr->next;
        free(ptr);
    }
    free(list);
}

Referenced by instruction_load(), and state_free().

instruction_load()

Instruction * instruction_load

(

char *

fname

)

Load instruction data from CSV file.

Parameters

fname

CSV file name/path to load from

Returns

loaded instructions or NULL on error

Opens the file, parses CSV and returns instruction data.
Checks for simple problems. Prints errors.
Returns NULL on error, and linked list (withut sentinel) otherwise.
Works both on Windows and Linux platforms with the same files.

Definition at line 18 of file instructions.c.

                                           {
    FILE* f = fopen(fname, "r");
    if (f == NULL) {
        ERROR("An error occured opening the file %s!\n", fname);
        ERROR("Error opening file: %s\n", strerror(errno));
        return NULL;
    }
 
    int rowindex = 0;
    char buff[16];
 
    int ptr = 0;
    int row = 1;
    Instruction* list = malloc(sizeof(Instruction));
 
    // ignore first line
    // (Also possibly has BOM for unicode)
    int x;
    while (x = fgetc(f), x != '\n' && x != EOF);
    if (x == EOF) {
        goto ERR_MALFORMED;
    }
    if (list == NULL) goto ERR_MEM;
    list->next = NULL;
    Instruction* curr = list;
 
 
    while (x = fgetc(f), x != EOF) {
        if (x == '\r') continue; // quick and dirty fix for linux opening a windows file
        if (x == ';' || x == '\n') {
            // end of column
            buff[ptr] = 0;
 
            // process data
            if (rowindex == 0) {
                if (ptr != 3) goto ERR_MALFORMED;
                memcpy(curr->mnem, buff, 3);
                curr->mnem[3] = 0;
            } else {
                if (ptr != 2 && ptr != 0) goto ERR_MALFORMED;
                if (ptr)
                    curr->opcs[rowindex - 1] = 16 * number_char_to_digit(buff[0]) + number_char_to_digit(buff[1]);
                else
                    curr->opcs[rowindex - 1] = OPC_INVALID;
            }
            ptr = 0;
            rowindex++;
            if (x == '\n') {
                if (rowindex != 14)
                    goto ERR_MALFORMED;
                rowindex = 0;
                row++;
 
                curr->next = malloc(sizeof(Instruction));
                if (curr->next == NULL) goto ERR_MEM;
                curr->next->next = NULL;
                curr = curr->next;
            }
 
 
            continue;
        }
        buff[ptr++] = x;
    }
 
    // file might had a trailing newline
    // in that case the last entry is not valid
 
    if (rowindex == 0) {
        for (curr = list; curr->next != NULL && curr->next->next != NULL; curr = curr->next);
        free(curr->next);
        curr->next = NULL;
    }
 
    fclose(f);
    return list;
ERR_MALFORMED:
    ERROR("Malformed instruction line:column: %d : %d\n", row + 1, rowindex + 1);
    ERROR("Malformed instructions/opcodes file: %s\n", fname);
    goto CLEANUP;
 
ERR_MEM:
    ERROR("Memory allocation error in instruction_load()!\n");
    goto CLEANUP;
 
CLEANUP:
    instruction_free(list);
    fclose(f);
 
    return NULL;
}

Referenced by state_load_instr().

instruction_print()

void instruction_print

(

Instruction *

instr

)

fancy-print one instruction data

Parameters

instr

instruction list entry to print

Fancy-print all data associated with one instruction (mnemonic, address modes and opcodes for them).
Useful for error reporting and debugging.

Definition at line 132 of file instructions.c.

                                           {
    printf("%s", instr->mnem);
    for (int i = 0; i < ADRM_COUNT; i++)
        if (instr->opcs[i] != OPC_INVALID) {
            printf("\t%s:\t%x\n", ADRM_NAMES[i], instr->opcs[i]);
        }
    printf("\n");
}

Referenced by instruction_print_all(), and pass_one().

instruction_print_all()

void instruction_print_all

(

Instruction *

list

)

debug-print all instructions in a list

Parameters

list	list of instructions to print

Fancy-print all instructions from the list using instruction_print()
Useful for debugging

Definition at line 141 of file instructions.c.

                                              {
    for (; list != NULL; list = list->next) {
        instruction_print(list);
    }
}

Field Documentation

mnem

char Instruction::mnem[4]

3-letter mnemonic of an instruction + trailing 0

Definition at line 27 of file instructions.h.

Referenced by instruction_find(), instruction_load(), and instruction_print().

next

struct Instruction* Instruction::next

Next instruction pointer on NULL.

Definition at line 31 of file instructions.h.

Referenced by instruction_find(), instruction_free(), instruction_load(), and instruction_print_all().

opcs

unsigned char Instruction::opcs[ADRM_COUNT]

Different combinarions of this instruction. Invalid ones are set to OPC_INVALID.

Definition at line 29 of file instructions.h.

Referenced by instruction_load(), and instruction_print().

---

The documentation for this class was generated from the following file:

• src/instructions.h