github.com/rzzzwilson.pymlac
1
0
Fork 0
mirror of https://github.com/rzzzwilson/pymlac.git synced 2025-06-10 09:32:41 +00:00
Code Issues Releases Wiki Activity

Working on PU test code

Browse Source
This commit is contained in:
Ross Wilson
2015-10-23 12:21:10 +07:00
parent 865c3e8d0d
commit 4d636df916
7 changed files with 221 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
vimlac/memory.c
View File

@@ -74,18 +74,18 @@ mem_put(WORD address, bool indirect, WORD value)
}
void
mem_clear(void)
mem_clear(WORD value)
{
if (rom_readonly)
{ /* save the ROM contents */
WORD rom[ROM_SIZE];
memcpy(rom, &memory[ROM_START], sizeof(WORD)*ROM_SIZE);
memset(memory, 0, sizeof(WORD)*MEM_SIZE);
memset(memory, value, sizeof(WORD)*MEM_SIZE);
memcpy(&memory[ROM_START], rom, sizeof(WORD)*ROM_SIZE);
}
else
memset(memory, 0, sizeof(WORD)*MEM_SIZE);
memset(memory, value, sizeof(WORD)*MEM_SIZE);
}
void

2
vimlac/memory.h
View File

@@ -12,7 +12,7 @@
WORD mem_get(WORD address, bool indirect);
void mem_put(WORD address, bool indirect, WORD value);
void mem_clear(void);
void mem_clear(WORD value);
void mem_set_rom(WORD *rom);
void mem_set_rom_readonly(bool readonly);
void mem_load_core(char *filename);

6
vimlac/plist.c
View File

@@ -8,7 +8,7 @@
* *
* PLIST PlistCreate(void); *
* *
* void PListInsert(PLIST plist, char *name, char *value); *
* void PlistInsert(PLIST plist, char *name, char *value); *
* *
* void *PlistFind(PLIST plist, char *name); *
* *
@@ -92,7 +92,7 @@ Description : Function to insert new record into the property list.
: New record placed in front of any existing equal record.
******************************************************************************/
void
PListInsert(PLIST plist, char *name, char *value)
PlistInsert(PLIST plist, char *name, char *value)
{
PList *hdr = (PList *) plist;
@@ -164,7 +164,6 @@ PlistDestroy(PLIST plist)
}
#ifdef DEBUG
/******************************************************************************
Name : PlistDump()
Description : Dump the plist to a specified open output FILE.
@@ -192,4 +191,3 @@ PlistDump(PLIST plist, FILE *output)
fprintf(output, " next: %p\n", hdr->next);
}
}
#endif

4
vimlac/plist.h
View File

@@ -23,12 +23,10 @@ typedef void *PLIST;
******/
PLIST PlistCreate(void);
void PListInsert(PLIST plist, char *name, char *value);
void PlistInsert(PLIST plist, char *name, char *value);
char *PlistFind(PLIST plist, char *name);
PLIST PlistDestroy(PLIST plist);
#ifdef DEBUG
void PlistDump(PLIST plist, FILE *output);
#endif
#endif

241
vimlac/test_cpu.c
View File

@@ -62,6 +62,7 @@
#include "memory.h"
#include "error.h"
#include "log.h"
#include "plist.h"
// string comparison macro
@@ -71,6 +72,9 @@
const char *LstFilename = "_#TEST#_.lst"; // LST filename
const char *AsmFilename = "_#TEST#_.asm"; // ASM filename
const int InitMemValue = 0;
const int InitRegValue = 0;
const int MaxLineSize = 4096; // max length of one script line
// command structures
@@ -100,14 +104,27 @@ bool DisplayOn = false;
int UsedCycles = 0;
WORD RegAllValue = 0;
WORD MemAllValue = 0;
Assoc *RememberReg;
PLIST MemValues = NULL;
PLIST RegValues = NULL;
/******************************************************************************
Description : Convert a string to upper case.
Parameters : str - address of string to convert
Returns :
Comments : The string is converted 'in situ'.
******************************************************************************/
void
remember(Assoc *head, char *name, WORD value)
strupper(char *str)
{
while (*str)
{
*str = toupper(*str);
++str;
}
}
/******************************************************************************
Description : Convert a string value into a WORD integer.
Parameters : str - address of string holding [0-9] characters
@@ -586,6 +603,9 @@ setmem(char *addr, char *fld2)
mem_put(address, false, value);
PlistInsert(MemValues, addr, fld2);
PlistDump(MemValues, NULL);
return 0;
}
@@ -690,53 +710,68 @@ checkcycles(char *cycles, char *fld2)
/******************************************************************************
Description : Check that a register contents is as expected.
Parameters : reg - string holding register name
: value - expected register value (string)
Parameters : reg - string holding register name
: expected - expected register value (string)
Returns : The number of errors encountered (0 or 1).
Comments :
******************************************************************************/
int
checkreg(char *reg, char *value)
checkreg(char *reg, char *expected)
{
WORD val = str2word(value);
WORD exp = str2word(expected);
char buffer[32];
strupper(reg);
if (STREQ(reg, "ac"))
if (STREQ(reg, "AC"))
{
remember(RememberReg, reg, cpu_get_AC());
if (cpu_get_AC() != val)
WORD value = cpu_get_AC();
sprintf(buffer, "%d", value);
PlistInsert(RegValues, reg, buffer);
if (value != exp)
{
vlog("AC is %07o, should be %07o", cpu_get_AC(), val);
printf("AC is %07o, should be %07o\n", cpu_get_AC(), val);
vlog("AC is %07o, should be %07o", value, exp);
printf("AC is %07o, should be %07o\n", value, exp);
return 1;
}
}
else if (STREQ(reg, "l"))
else if (STREQ(reg, "L"))
{
remember(RememberReg, reg, cpu_get_L());
if (cpu_get_L() != val)
WORD value = cpu_get_L();
sprintf(buffer, "%d", value);
PlistInsert(RegValues, reg, buffer);
if (value != exp)
{
vlog("L is %02o, should be %02o", cpu_get_L(), val);
printf("L is %02o, should be %02o\n", cpu_get_L(), val);
vlog("L is %02o, should be %02o", value, exp);
printf("L is %02o, should be %02o\n", value, exp);
return 1;
}
}
else if (STREQ(reg, "pc"))
else if (STREQ(reg, "PC"))
{
remember(RememberReg, reg, cpu_get_PC());
if (cpu_get_PC() != val)
WORD value = cpu_get_PC();
sprintf(buffer, "%d", value);
PlistInsert(RegValues, reg, buffer);
if (value != exp)
{
vlog("PC is %07o, should be %07o", cpu_get_PC(), val);
printf("PC is %07o, should be %07o\n", cpu_get_PC(), val);
vlog("PC is %07o, should be %07o", value, exp);
printf("PC is %07o, should be %07o\n", value, exp);
return 1;
}
}
else if (STREQ(reg, "ds"))
else if (STREQ(reg, "DS"))
{
remember(RememberReg, reg, cpu_get_DS());
if (cpu_get_DS() != val)
WORD value = cpu_get_DS();
sprintf(buffer, "%d", value);
PlistInsert(RegValues, reg, buffer);
if (value != exp)
{
vlog("DS is %07o, should be %07o", cpu_get_DS(), val);
printf("DS is %07o, should be %07o\n", cpu_get_DS(), val);
vlog("DS is %07o, should be %07o", value, exp);
printf("DS is %07o, should be %07o\n", value, exp);
return 1;
}
}
@@ -793,14 +828,35 @@ Description : Check that a memory address contents is as expected.
Parameters : address - memory address to check (string)
: value - expected memory value (string)
Returns : The number of errors encountered (0 or 1).
Comments :
Comments : We check the MemValues plist first!
******************************************************************************/
int
checkmem(char *address, char *value)
{
WORD adr = str2word(address);
WORD val = str2word(value);
WORD memvalue = mem_get(adr, false);
WORD memvalue;
char *charvalue;
printf("checkmem: address=%s, value=%s", address, value);
// check the plist first
charvalue = PlistFind(MemValues, address);
if (charvalue)
{ // in the plist, check value
memvalue = str2word(charvalue);
if (memvalue != val)
{
printf("Memory at address %07o is %07o, should be %07o\n",
adr, memvalue, val);
return 1;
}
return 0;
}
// now check actual memory
memvalue = mem_get(adr, false);
if (memvalue != val)
{
@@ -853,10 +909,114 @@ checkrun(char *state, char *unused)
}
/******************************************************************************
Description : Check that memory values are as they should be.
Parameters :
Returns : The number of errors encountered.
Comments : Expected values shopuld be the global 'MemAllValue' or one of the
: values in the 'MemValues' plist.
******************************************************************************/
int
check_all_mem(void)
{
int result = 0;
char buffer[32];
printf("check_all_mem: entered\n");
for (WORD adr = 0; adr < MEM_SIZE; ++adr)
{
WORD value = mem_get(adr, false);
sprintf(buffer, "%04o", adr);
char *expected = PlistFind(MemValues, buffer);
if (adr == 0100)
{
printf("Checking %07o, PlistFind() returned %s for '%s'\n",
adr, expected, buffer);
PlistDump(MemValues, NULL);
}
if (expected)
{
if (expected != buffer)
{
printf("Memory at %07o changed, is %07o, should be %07o\n",
adr, value, str2word(expected));
result += 1;
}
}
else
{
if (value != MemAllValue)
{
printf("Memory at %07o changed, is %07o, should be %07o\n",
adr, value, MemAllValue);
result += 1;
}
}
}
return result;
}
/******************************************************************************
Description : Check that a register value is as it should be.
Parameters : reg - register name
Returns : The number of errors encountered.
Comments : Expected values should be the value in 'RegValues' plist.
******************************************************************************/
int
check_reg(char *reg)
{
char *expect_str = PlistFind(RegValues, reg);
WORD expect = str2word(expect_str);
WORD value;
if (STREQ(reg, "AC")) value = cpu_get_AC();
else if (STREQ(reg, "L")) value = cpu_get_L();
else if (STREQ(reg, "PC")) value = cpu_get_PC();
else if (STREQ(reg, "DS")) value = cpu_get_DS();
else
{
printf("check_reg: bad register name '%s'\n", reg);
return 1;
}
if (value != expect)
{
printf("Register %s has bad value, expected %07o got %07o\n",
reg, expect, value);
return 1;
}
return 0;
}
/******************************************************************************
Description : Check that register values are as they should be.
Parameters :
Returns : The number of errors encountered.
Comments : Expected values should be the value in 'RegValues' plist.
******************************************************************************/
int
check_all_regs(void)
{
int result = 0;
result += check_reg("AC");
result += check_reg("L");
result += check_reg("PC");
result += check_reg("DS");
return result;
}
/******************************************************************************
Description : Run all commands in one test line.
Parameters : test - pointer to a Test struct
Returns : The number of errors encountered (0 or 1).
Returns : The number of errors encountered.
Comments :
******************************************************************************/
int
@@ -865,6 +1025,20 @@ run_one_test(Test *test)
int error = 0;
char buffer[256];
// set up memory/register value data structures
MemValues = PlistCreate();
RegValues = PlistCreate();
// set memory and registers to known initial values
MemAllValue = InitMemValue;
mem_clear(InitMemValue);
RegAllValue = InitRegValue;
cpu_set_AC(InitRegValue);
cpu_set_L(InitRegValue & 1);
cpu_set_PC(InitRegValue);
cpu_set_DS(InitRegValue);
for (Command *cmd = test->commands; cmd; cmd = cmd->next)
{
char *opcode = cmd->opcode;
@@ -908,6 +1082,13 @@ run_one_test(Test *test)
}
}
// now check all memory and regs for changes
error += check_all_mem();
error += check_all_regs();
// destroy any created data structures
MemValues = PlistDestroy(MemValues);
return error;
}
@@ -981,7 +1162,6 @@ execute(char *script)
// get test commands into massaged form in memory
test = parse_script(script);
#ifdef DEBUG
// DEBUG - print contents of 'test'
for (Test *tscan = test; tscan != NULL; tscan = tscan->next)
{
@@ -993,7 +1173,6 @@ execute(char *script)
printf("\n");
fflush(stdout);
}
#endif
// execute tests
return run(test);

6
vimlac/test_memory.c
View File

@@ -17,7 +17,7 @@ main(int argc, char *argv[])
FILE *fd;
// test the "memory clear" function
mem_clear();
mem_clear(0);
for (addr = 0; addr < MEM_SIZE; ++addr)
assert(mem_get(addr, false) == 0);
@@ -112,7 +112,7 @@ main(int argc, char *argv[])
// now save memory to a file
mem_set_rom_readonly(false);
mem_clear();
mem_clear(0);
for (addr = 0; addr < MEM_SIZE; ++addr)
mem_put(addr, false, addr);
fd = fopen("imlac.core", "wb");
@@ -120,7 +120,7 @@ main(int argc, char *argv[])
fclose(fd);
// clear memory and read core file back in
mem_clear();
mem_clear(0);
fd = fopen("imlac.core", "rb");
mem_load_core(fd);
fclose(fd);

2
vimlac/vimlac.c
View File

@@ -65,7 +65,7 @@ run(WORD pc)
int
main(void)
{
mem_clear();
mem_clear(0);
mem_set_rom(PtrROMImage);
ptr_mount("test_add.ptp");
run(040);