Help on brookshear machine

Hi, I am trying to code a brookshear machine and I am getting weird results with my code.

My Code:

Code:

---

#include <stdio.h>


void display_values(unsigned int pc, unsigned char mem[], unsigned char reg[]);


FILE *f;


int main() {
    unsigned int pc = 0, i = 0, temp = 0;
    unsigned char reg[16], mem[256], a, b, c, d, cd;
   
    for(i = 0; i < sizeof(reg); i++) {
        reg[i] = 0x00;
    }
   
    for(i = 0; i < sizeof(mem); i++) {
        mem[i] = 0x00;
    }
   
    f = fopen("a3.txt", "r");
    if(f == NULL) {
        printf("Error: File not found!\n");
        return 0;
    }
   
    while(fscanf(f, "%X", &temp) != EOF) {
        mem[i] = (temp & 0xff00) >> 8;
        mem[i+1] = temp & 0xff;
        i+=2;
    }
    fclose(f);
   
    while(mem[pc] != 0xC0) {
        a = (mem[i] & 0xf0) >> 4;
        b = mem[i] & 0xf;
        c = (mem[i+1] & 0xf0) >> 4;
        d = mem[i+1] & 0xf;
        cd = mem[i+1];
       
        display_values(pc, mem, reg);
       
        if(a == 0x1) {
            // Load the register R with the value at memory address XY.
            reg[b] = mem[cd];
        }
        if(a == 0x2) {
            // Load register R with the value XY.
            reg[b] = cd;
        }
        if(a == 0x3) {
            // Store the value in register R at memory address XY.
            mem[cd] = reg[b];
        }
        if(a == 0x4) {
            // Move the value in register R to register S.
            reg[d] = reg[c];
            reg[c] = 0x00;
        }
        if(a == 0x5) {
            // Add(+) values in registers R and S and put the answer in register T.
            reg[d] = reg[b] + reg[c];
        }
        if(a == 0x7) {
            // Bit-wise OR(|) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] | reg[c];
        }
        if(a == 0x8) {
            // Bit-wise AND(&) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] & reg[c];
        }
        if(a == 0x9) {
            // Bit-wise XOR(^) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] ^ reg[c];
        }
        if(a == 0xA) {
            // Rotate the contents of register R X times to the right.
            reg[b] >>= 1;
            reg[b] = reg[b] | ((reg[b] & 0x1) << 31);
        }
        if(a == 0xB) {
            // Jump to the instruction located at memory address XY if register R = register 0.
            if(mem[b] == reg[0]) {
                pc = cd;
            }
        }
       
        pc = pc + 2;
       
        display_values(pc, mem, reg);
    }
   
    return 0;
}


void display_values(unsigned int pc, unsigned char mem[], unsigned char reg[]) {   
    unsigned int i = 0;
   
    printf("%02X", pc);
    printf(" %02X%02X ", mem[pc], mem[pc+1]);
    for(i = 0; i < sizeof(reg); i++) {
        printf(" %02X ", reg[i]);
    }
    printf("\n");
}

---

I am reading from a text file that contains:

Quote:

---

B404
239A
2412
5345
350C
C000

---

The right result is:

Quote:

---

00 B404 – [00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00]
04 2412 - [00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00]
06 5345 - [00 00 00 00 12 00 00 00 00 00 00 00 00 00 00 00]
08 350C - [00 00 00 00 12 12 00 00 00 00 00 00 00 00 00 00]
0A C000 - [00 00 00 00 12 12 00 00 00 00 00 00 00 00 00 00]

---

But I am getting: (Note: it started from 00...)
Attachment 12703


Need help. :frown:

Code:

---

void display_values(unsigned int pc, unsigned char mem[], unsigned char reg[]) {   
    unsigned int i = 0;
   
    printf("%02X", pc);
    printf(" %02X%02X ", mem[pc], mem[pc+1]);
    for(i = 0; i < sizeof(reg); i++) {
        printf(" %02X ", reg[i]);
    }
    printf("\n");
}

---

"reg" is a pointer, thus sizeof(reg) gives you the size of a pointer. You need to pass the actual length of the array to your function.

Bye, Andreas

ok, i got the 16 registers to show now. but they are still all zeroes and the counter still runs from 00 to 108.

When reusing variables you have to reset then to sane values.
set i to 0 before reading from the file.

also

Code:

---

    while(mem[pc] != 0xC0) {
        a = (mem[i] & 0xf0) >> 4;
        b = mem[i] & 0xf;
        c = (mem[i+1] & 0xf0) >> 4;
        d = mem[i+1] & 0xf;
        cd = mem[i+1];

---

i never changes in that loop

Kurt

Show us the new version.

In the old one you don't reset "i" before the second while loop and never update "i" inside it.

Bye, Andreas

ok, here is the new code. Changes:

• changed unsigned char to unsigned int
• initialised all values
• removed sizeof()
• changed "i" to "pc" in while(mem[pc] != 0xC0) { ... }

Code:

---

#include <stdio.h>


void display_values(unsigned int pc, unsigned int mem[], unsigned int reg[]);


FILE *f;
unsigned int size_mem = 256, size_reg = 16;


int main() {
    unsigned int pc = 0, i = 0, temp = 0;
    unsigned int  a = 0, b = 0, c = 0, d = 0, cd = 0;
    unsigned int reg[size_reg], mem[size_mem];
   
    for(i = 0; i < size_reg; i++) {
        reg[i] = 0x00;
    }
   
    for(i = 0; i < size_mem; i++) {
        mem[i] = 0x00;
    }
   
    f = fopen("a3.txt", "r");
    if(f == NULL) {
        printf("Error: File not found!\n");
        return 0;
    }
   
    while(fscanf(f, "%X", &temp) != EOF) {
        mem[i] = (temp & 0xff00) >> 0x8;
        mem[i+1] = temp & 0xff;
        i += 2;
    }
    fclose(f);
   
    while(mem[pc] != 0xC0) {
        a = (mem[pc] & 0xf0) >> 0x4;
        b = mem[pc] & 0xf;
        c = (mem[pc+1] & 0xf0) >> 0x4;
        d = mem[pc+1] & 0xf;
        cd = mem[pc+1];
       
        if(a == 0x1) {
            // Load the register R with the value at memory address XY.
            reg[b] = mem[cd];
        }
        if(a == 0x2) {
            // Load register R with the value XY.
            reg[b] = cd;
        }
        if(a == 0x3) {
            // Store the value in register R at memory address XY.
            mem[cd] = reg[b];
        }
        if(a == 0x4) {
            // Move the value in register R to register S.
            reg[d] = reg[c];
            reg[c] = 0x00;
        }
        if(a == 0x5) {
            // Add(+) values in registers R and S and put the answer in register T.
            reg[d] = reg[b] + reg[c];
        }
        if(a == 0x7) {
            // Bit-wise OR(|) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] | reg[c];
        }
        if(a == 0x8) {
            // Bit-wise AND(&) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] & reg[c];
        }
        if(a == 0x9) {
            // Bit-wise XOR(^) the values in registers R and S and put the answer in register T.
            reg[d] = reg[b] ^ reg[c];
        }
        if(a == 0xA) {
            // Rotate the contents of register R X times to the right.
            reg[b] >>= 1;
            reg[b] = reg[b] | ((reg[b] & 0x1) << 31);
        }
        if(a == 0xB) {
            // Jump to the instruction located at memory address XY if register R = register 0.
            if(mem[b] == reg[0]) {
                pc = cd;
            }
        }
       
        display_values(pc, mem, reg);
       
        pc += 2;
    }
   
    return 0;
}


void display_values(unsigned int pc, unsigned int mem[], unsigned int reg[]) {   
    unsigned int i = 0;
   
    printf("%02X", pc);
    printf(" %02X%02X - [", mem[pc], mem[pc+1]);
    for(i = 0; i < size_reg; i++) {
        printf(" %02X ", reg[i]);
    }
    printf("]\n");
}

---

...and here is the new result:
Attachment 12704

All of the bit fiddling techniques in main(), and the magic hex values, mean that your code is assuming a particular endianness on your target machine. If your target machine is a different endianness, the results will not be what you expect.

Looping until fscanf() returns EOF is not a good idea, as fscanf() can return values other than EOF when certain errors occur (such as a character that cannot be interpreted as a hex digit, in your case). When starting that loop, the value of i will also be equal to size_mem.

If you want to set arrays to zero, it is often better to either initialise them that way or to use memcpy().

do you mean something like...

Code:

---

unsigned int reg[size_reg] = {0}, mem[size_mem] = {0};

---

...when initialising arrays?

That's one way.

tried it and i am getting an error message saying "variable-sized object `reg' may not be initialized" and "variable-sized object `mem' may not be initialized" if i initialise the arrays to zero using that method. :frown:

Oh, okay. That's because size_reg is a variable (and your arrays are therefore VLAs). Try making the sizes visible to the compiler at compile time (e.g. #define size_mem 256 or [slightly more devious] an enum trick), rather than as values of variables.

If the sizes really must be variables, then use something like memcpy() or memset().

Quote:

---

Originally Posted by ZuK

When reusing variables you have to reset then to sane values.
set i to 0 before reading from the file.

---

Code:

---

    while(fscanf(f, "%X", &temp) != EOF) {
        mem[i] = (temp & 0xff00) >> 0x8;
        mem[i+1] = temp & 0xff;
        i += 2;
    }

---

What's the value of "i" before you read the file?

Bye, Andreas

well, there are no requirements to have the array size as a variable...thats just me wanting to explore more functions. :)

anyway, I have changed the code again to this:

Code:

---

#include <stdio.h>


#define size_mem 256
#define size_reg 16


void display_values(unsigned int pc, unsigned int mem[], unsigned int reg[]);


FILE *f;




int main() {
        unsigned int pc = 0, i = 0, temp = 0;
        unsigned int a = 0, b = 0, c = 0, d = 0, cd = 0;
        unsigned int reg[size_reg] = {0}, mem[size_mem] = {0};
       
        f = fopen("a3.txt", "r");
        if(f == NULL) {
                printf("Error: File not found!\n");
                return 0;
        }
       
        while(fscanf(f, "%X", &temp) != EOF) {
                mem[i] = (temp & 0xff00) >> 0x8;
                mem[i+1] = temp & 0xff;
                i += 2;
        }
        fclose(f);
       
        while(mem[pc] != 0xC0) {
                a = (mem[pc] & 0xf0) >> 0x4;
                b = mem[pc] & 0xf;
                c = (mem[pc+1] & 0xf0) >> 0x4;
                d = mem[pc+1] & 0xf;
                cd = mem[pc+1];
               
                if(a == 0x1) {
                        // Load the register R with the value at memory address XY.
                        reg[b] = mem[cd];
                }
                if(a == 0x2) {
                        // Load register R with the value XY.
                        reg[b] = cd;
                }
                if(a == 0x3) {
                        // Store the value in register R at memory address XY.
                        mem[cd] = reg[b];
                }
                if(a == 0x4) {
                        // Move the value in register R to register S.
                        reg[d] = reg[c];
                        reg[c] = 0x00;
                }
                if(a == 0x5) {
                        // Add(+) values in registers R and S and put the answer in register T.
                        reg[d] = reg[b] + reg[c];
                }
                if(a == 0x7) {
                        // Bit-wise OR(|) the values in registers R and S and put the answer in register T.
                        reg[d] = reg[b] | reg[c];
                }
                if(a == 0x8) {
                        // Bit-wise AND(&) the values in registers R and S and put the answer in register T.
                        reg[d] = reg[b] & reg[c];
                }
                if(a == 0x9) {
                        // Bit-wise XOR(^) the values in registers R and S and put the answer in register T.
                        reg[d] = reg[b] ^ reg[c];
                }
                if(a == 0xA) {
                        // Rotate the contents of register R X times to the right.
                        temp = (reg[b] & 0x1);
                        reg[b] >>= 1;
                        reg[b] = reg[b] | ( temp << 31);
                }
                if(a == 0xB) {
                        // Jump to the instruction located at memory address XY if register R = register 0.
                        if(mem[b] == reg[0]) {
                                pc = cd;
                        }
                }
               
                display_values(pc, mem, reg);
               
                pc += 2;
        }
       
        return 0;
}


void display_values(unsigned int pc, unsigned int mem[], unsigned int reg[]) {       
        unsigned int i = 0;
       
        printf("%02X", pc);
        printf(" %02X%02X - [", mem[pc], mem[pc+1]);
        for(i = 0; i < size_reg; i++) {
                printf(" %02X ", reg[i]);
        }
        printf("]\n");
}

---

...and the result is this:
Attachment 12705

it looks more correct now. will have to try to solve it by hand to see if it actually is. :)

Quote:

---

Originally Posted by AndiPersti

Code:

---

    while(fscanf(f, "%X", &temp) != EOF) {
        mem[i] = (temp & 0xff00) >> 0x8;
        mem[i+1] = temp & 0xff;
        i += 2;
    }

---

What's the value of "i" before you read the file?

Bye, Andreas

---

I initialised i = 0.

Quote:

---

Originally Posted by grumpy

Oh, okay. That's because size_reg is a variable (and your arrays are therefore VLAs). Try making the sizes visible to the compiler at compile time (e.g. #define size_mem 256 or [slightly more devious] an enum trick), rather than as values of variables.

If the sizes really must be variables, then use something like memcpy() or memset().

---

i used #define but im curious about the enum. do you use it on the array size or the array itself?

Quote:

---

Originally Posted by Warzaw

i used #define but im curious about the enum. do you use it on the array size or the array itself?

---

The enum trick (or hack) is used to attach a name to a value, which can be checked by the compiler

Code:

---

enum {size_reg = 16, size_mem = 256};

int main()
{
      int regs[size_reg], mem[size_mem];
        /* whatever */
}

---

This works because an enumeration (even an anonymous enumeration, as in the example) must have all its values known at compile time.

It is a bit of a dirty trick though, and can be subverted (eg if a variable has the same name as one of the enumeration values).

i see. so its best to use #define for now. though its good to know there is a possible alternative.

anyway, i was able to get the brookshear program working. thank you guys for the help. :)