TRESSEL User's Guide

TRESSEL Documentation > TRESSEL User's Guide

-- TRESSEL Platform Description --

-- Reference Types --

-- Instructions Listing --

-- Examples of Instruction Operands --

-- Directives Listing --

-- Using the TRESSEL SDK --

-- Sample Program and Output --

-- Running the Assembler --

-- Running the Linker --

-- Running the Simulator --

-- Compiling through Execution --

-- Load and Execution of TRESSEL Programs --

-- Assembler Error Messages --

-- Linker Error Messages --

-- Simulator Error Messages --

-- Software Limitations --

About the TRESSEL platform Return To Top

The TRESSEL platform is an exclusive computing platform which runs TRESSEL assembly code. The platform has a memory capacity of 4096 words with each word being 24 bits. It has 6 programmable registers as well as 4 non-addressable registers, listed below. The machine supports four addressing modes: relative to start, relative to Base Register, direct, and indirect. Star addressing is supported by the assembler allowing addresses in operands to refer to the current instruction address. TRESSEL supports relocation of executable code. The Tressel SDK provides an assembler, linker, and emulator. This runs a two-pass assembler, which helps in the optimization of program complexity. It allows forward declaration of labels, end-pooled literals, and improved error messages. With over 50 instructions and 20 directives, the TRESSEL machine allows ultimate versatility. Labels are also required to be declared in column 1 to help ensure that users can use, both instruction and directive mnemonics, as label name declarations. Labels are also CASE-SENSITIVE, which allows for an optimal range of available labels. The linker and loader we used is a mixed implementation of both the BSS (Binary Symbolic Subroutine System) and DLL (Direct Linking Loader). The three main parts of our compiler are all decoupled as seperate executables. There's the assembler, linker, and loader/simulator. the assembler outputs an object file, which is inputted to the linker, which outputs a load file, which is inputted to the simulator, which actually runs and simultes the TRESSEL code, with a memory dump saved to a text file.

Programmable Registers:

Register	Name	Size	Purpose
AC	Accumulator	24 bits	Used for arithmetic and bitwise operations.
BR	Base	16 bits	Used for module relocation.
IR	Index	16 bits	Used for indexed addressing, loop counter, etc.
AR	Alternative	24 bits	Used for storing intermediate values.
PR	Parameter List Address	16 bits	Address of parameter list for subprogram link when linking.
SR	Status	16 bits	Status of last instruction executed.

Non-Addressable Registers:

Register	Name	Size	Purpose
LC	Location Counter	24 bits	Holds the address of the current instruction.
NIC	Next Instruction Counter	24 bits	Holds the address of the next instruction to be executed.
EFFADDR	Effective Address	16 bits	Holds the address of the data to be read from memory.
IWD	Instruction Word	24 bits	Holds the current instruction being executed.

Reference Types Return To Top

type 1	A number in the range 0 to 2047.
type 2	A number in the range 0 to 2047 or an Equated(EQU) symbol in the same range.
type 3	A number or Equated(EQU) symbol in the range of 0 to 2.
type 4	A number or Equated(EQU) symbol in the range of 0 to 23.
EXPRESSION 1	Expression type for the directive 'EQU-exp'. This expression can contain a constant or a previously Equated(EQU) symbol. This expression can supports up to 4 operators in it which the results of these must be in the
EXPRESSION 2	Expression type for the directive 'COMP'. This expression can contain a constant or a previously Equated(EQU) symbol. Does not support the use of parantheses.
EXPRESSION 3	Expression type for the directive 'Adr-COMP'. This expression can contain local labels, external labels, or constants. This expression also only works on addresses (will not work on values).
REF-ALL	This type can be a 'Reference', '#Reference', '%Reference' or 'Reference-Exp' type.
Reference	This type of Reference can contain label, symbol, number, or Equated(EQU) symbol. This type represents a memory location.
#Reference	This type of Reference can contain label, symbol, number, or Equated(EQU) symbol. This type represents a physical location.
%Reference	This type of Reference can contain label, symbol, number, or Equated(EQU) symbol. This type represents an indirect memory location.
Reference-Exp	This type of Reference starts with a '*' character. It must be followed by a '+' or '-' character which is then followed by a constant or Equated(EQU) symbol.
Literal	This type supports base 10(decimal), base 16(hexadecimal), base 2(binary) and characters(limit 3 characters). It must start by a '=' character followed by certain acceptable format according the supported type. For base 10(decimal), a number must follows the '=' with each digit ranging from 0-9. For base 16(hexadecimal), a number must follows the '=' with each digit ranging from 0-9 or A-F. Then it must be ended by a letter 'h'or 'H'. For base 2(binary), a number must follows the '=' with each digit is either 0 or 1. Then it must be ended by a letter 'b' or 'B'. For characters, a ' ' ' character must follows the '=' and ended the expression. Between the quotation marks, a limit of 3 characters from A to Z or a to z may be assigned.

**NOTE: Declared Labels are CASE-SENSITIVE.

Instructions Return To Top

Binary Opcode	Hex	Mnemonic	Operand Type	Description	Action
000000	0	LD-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and loads that value in to the AC; clears all previous contents.	c(AC)=c(memory(effadd))
000001	1	ST-AC	REF-ALL	Retrieves the value from the AC, traces to the address specified in the operand, stores the value in to the memory.	c(memory(effadd))=AC
000010	2	LD-IR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and loads that value in to the IR; clears all previous contents.	c(IR)=c(memory(effadd))
000011	3	ST-IR	REF-ALL	Retrieves the value from the IR, traces to the address specified in the operand, stores the value in to the memory.	c(memory(effadd))=IR
000100	4	LD-AR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and loads that value in to the AR; clears all previous contents.	c(AR)=c(memory(effadd))
000101	5	ST-AR	REF-ALL	Retrieves the value from the AR, traces to the address specified in the operand, stores the value in to the memory.	c(memory(effadd))=AR
000110	6	LD-BR	*	Traces to the address specified in the operand, retrieves the value from memory, and loads that value in to the BR; clears all previous contents.	c(BR)=current memory address Must immediately follow a Using
000111	7	ST-BR	REF-ALL	Retrieves the value from the BR, traces to the address specified in the operand, stores the value in to the memory.	c(memory(effadd))=BR
001000	8	ADD-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and adds that value to the AC.	c(AC)=c(AC)+c(mem(effadd))
001001	9	SUB-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and subtracts that value from the AC.	c(AC)=c(AC)-c(mem(effadd))
001010	A	MUL-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and multiplies that value to the AC.	c(AC)=c(AC)*c(mem(effadd))
001011	B	DIV-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and divides the AC by that value.	c(AC)=c(AC)/c(mem(effadd))
001100	C	ADD-IR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and adds that value to the IR.	c(IR)=c(IR)+c(mem(effadd))
001101	D	SUB-IR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and subtracts that value from the IR.	c(IR)=c(IR)-c(mem(effadd))
001110	E	MUL-IR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and multiplies that value to the IR.	c(IR)=c(IR)*c(mem(effadd))
001111	F	DIV-IR	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, and divides the IR by that value.	c(IR)=c(IR)/c(mem(effadd))
010000	10	AND-AC	REF-ALL	Performs an AND operation with the AC value and the value from memory.	c(AC)=c(AC) AND c(mem(effadd))
010001	11	OR-AC	REF-ALL	Performs an OR operation with the AC value and the value from memory.	c(AC)=c(AC) OR c(mem(effadd))
010010	12	LAND-AC	REF-ALL	Performs a Logical AND operation with the AC value and the value from memory.	c(AC)=c(AC) AND c(mem(effadd))
010011	13	LOR-AC	REF-ALL	Performs a Logical OR operation with the AC value and the value from memory.	c(AC)=c(AC) OR c(mem(effadd))
010100	14	ABS-AC	REF-ALL	Absolutes the AC value.	c(AC)=\|c(AC)\|
010101	15	AND-IR	REF-ALL	Performs an AND operation with the IR value and the value from memory.	c(IR)=c(IR) AND c(mem(effadd))
010110	16	OR-IR	REF-ALL	Performs an OR operation with the IR value and the value from memory.	c(IR)=c(IR) OR c(mem(effadd))
010111	17	LAND-IR	REF-ALL	Performs a Logical AND operation with the IR value and the value from memory.	c(IR)=c(IR) AND c(mem(effadd))
011000	18	LOR-IR	REF-ALL	Performs a Logical OR operation with the IR value and the value from memory.	c(IR)=c(IR) OR c(mem(effadd))
011001	19	AND-SR	REF-ALL	Performs an AND operation with the SR value and the value from memory.	c(SR)=c(SR) AND c(mem(effadd))
011010	1A	OR-SR	REF-ALL	Performs an OR operation with the SR value and the value from memory.	c(SR)=c(SR) OR c(mem(effadd))
011011	1B	ABS-IR	IARn	Absolutes the IR value.	c(IR)=\|c(IR)\|
011100	1C	SLA-AC	type 4	Shifts all the bit values of the AC to the left. Empty positions in the least significant bits will be filled with 0's. The operand will be the number of shifts.	c(AC)=c(AC) [Shifted Left] effadd
011101	1D	SRA-AC	type 4	Shifts all the bit values of the AC to the right. Empty positions in the most significant bits will be filled with the copy of the most significant bit of the original AC. The operand will be the number of shifts.	c(AC)=c(AC) [Right Shifted] effadd
011110	1E	SLL-AC	type 4	Shifts all the bit values of the AC to the left. Empty positions in the least significant bits will be filled with 0's. The operand will be the number of shifts.	c(AC)=c(AC) [Shifted Left] effadd
011111	1F	SRL-AC	type 4	Shifts all the bit values of the AC to the right. Empty positions in the most significant bits will be filled with 0's. The operand will be the number of shifts.	c(AC)=c(AC) [Right Shifted] effadd
100000	20	RROT-AC	type 4	Rotate the bits in the AC to the right; specified by the operand number inputted.	c(AC)=c(AC) [Right rotated] effadd
100001	21	LROT-AC	type 4	Rotate the bits in the AC to the left; specified by the operand number inputted.	c(AC)=c(AC) [left rotated] effadd
100010	22	SLA-IR	type 4	Shifts all the bit values of the IR to the left. Empty positions in the least significant bits will be filled with 0's. The operand will be the number of shifts.	c(IR)=c(IR) [Shifted Left] effadd
100011	23	SRA-IR	type 4	Shifts all the bit values of the IR to the right. Empty positions in the most significant bits will be filled with the copy of the most significant bit of the original AC. The operand will be the number of shifts.	c(IR)=c(IR) [Right Shifted] effadd
100100	24	SLL-IR	type 4	Shifts all the bit values of the IR to the left. Empty positions in the least significant bits will be filled with 0's. The operand will be the number of shifts.	c(IR)=c(IR) [Shifted Left] effadd
100101	25	SRL-IR	type 4	Shifts all the bit values of the IR to the right. Empty positions in the most significant bits will be filled with 0's. The operand will be the number of shifts.	c(IR)=c(IR) [Right Shifted] effadd
100110	26	RROT-IR	type 4	Rotate the bits in the IR to the right; specified by the operand number inputted.	c(IR)=c(IR) [Right rotated] effadd
100111	27	LROT-IR	type 4	Rotate the bits in the IR to the left; specified by the operand number inputted.	c(IR)=c(IR) [left rotated] effadd
101000	28	LDN-AC	REF-ALL	Traces to the address specified in the operand, retrieves the value from memory, negates the sign of the valud, and loads that in to the AC; clears all previous contents.
101001	29	CURRENTLY UNUSED
101010	2A	HALT	type 3	Halts the program execution, and returns the operand value to the assembler.
101011	2B	CURRENTLY UNUSED
101100	2C	JMP-PR-LT	REF-ALL	Jump to the address specified in the operand, if PR value is less than 0; must be within the range of the program.	If c(PR)<0 LC=effadd
101101	2D	JMP-SR-GT	REF-ALL	Jump to the address specified in the operand, if SR value is greater than 0; must be within the range of the program.	If c(SR)>0 LC=effadd
101110	2E	JMP-SR-EQ	REF-ALL	Jump to the address specified in the operand, if SR value is equal to 0; must be within the range of the program.	If c(SR)=0 LC=effadd
101111	2F	JMP-SR-LT	REF-ALL	Jump to the address specified in the operand, if SR value is less than 0; must be within the range of the program.	If c(SR)<0 LC=effadd
110000	30	JMP	REF-ALL	Jump to the address specified in the operand; must be within the range of the program.	LC=effadd
110001	31	JMP-AC-GT	REF-ALL	Jump to the address specified in the operand, if AC value is greater than 0;	If c(AC)>0 LC=effadd
110010	32	JMP-AC-EQ	REF-ALL	Jump to the address specified in the operand, if AC value is equal to 0;	If c(AC)=0 LC=effadd
110011	33	JMP-AC-LT	reference	Jump to the address specified in the operand, if AC value is less than 0;	If c(AC)<0 LC=effadd
110100	34	JMP-IR-GT	reference	Jump to the address specified in the operand, if IR value is greater than 0;	If c(IR)>0 LC=effadd
110101	35	JMP-IR-EQ	reference	Jump to the address specified in the operand, if IR value is equal to 0;	If c(IR)=0 LC=effadd
110110	36	JMP-IR-LT	reference	Jump to the address specified in the operand, if IR value is less than 0;	If c(IR)<0 LC=effadd
110111	37	DISPLAY	type 3	If the operand is 0, then display ALL registers; Else If the operand is 1, then display LC and the value located in the memory indicated by LC; Else If the operand is 2, then ***********************	If 0 Display All registers. If 1 Display LC and c(mem(LC)). If 2 Display active memory locations in a matrix format.
111000	38	READ-NUM	REF-ALL	Reads a number from keyboard, and store the input into the memory location specified in the operand.	Store results into c(memory(effadd))
111001	39	READ-STR	REF-ALL	Reads string from keyboard, and store the input into the memory location specified in the operand	Store results into c(memory(effadd))
111010	3A	WRITE-NUM	REF-ALL	Prints number located in the memory specified in the operand.	"""WRITE"" from c(memory(effadd))"
111011	3B	WRITE-STR	REF-ALL	Prints string located in the memory specified in the operand.	"""WRITE"" from c(memory(effadd))"
111100	3C	LD-AC-ADR	REF-ALL	Loads the AC with address value of the operand; clears all previous contents.	c(AC)=effadd
111101	3D	LD-IR-ADR	REF-ALL	Loads the IR with address value of the operand; clears all previous contents.	c(IR)=effadd
111110	3E	LD-BR-ADR	*	Loads the BR with address value of the operand; clears all previous contents.	c(BR)=effadd

Examples of Instruction Operands Return To Top

mnemonic	Example
LD-AC	LD-AC 10 LD-AC X10 LD-AC MUD LD-AC %MUD LD-AC #MUD LD-AC *+10
ST-AC	ST-AC 10 ST-AC X10 ST-AC MUD ST-AC %MUD ST-AC #MUD ST-AC *+10
LD-IR	LD-IR 10 LD-IR X10 LD-IR MUD LD-IR %MUD LD-IR #MUD LD-IR *+10
ST-IR	ST-IR 10 ST-IR X10 ST-IR MUD ST-IR %MUD ST-IR #MUD ST-IR *+10
LD-AR	LD-AR 10 LD-AR X10 LD-AR MUD LD-AR %MUD LD-AR #MUD LD-AR *+10
ST-AR	ST-AR 10 ST-AR X10 ST-AR MUD ST-AR %MUD ST-AR #MUD ST-AR *+10
LD-BR	LD-BR *
ST-BR	ST-BR 10 ST-BR X10 ST-BR MUD ST-BR %MUD ST-BR #MUD ST-BR *+10
ADD-AC	ADD-AC 10 ADD-AC X10 ADD-AC MUD ADD-AC %MUD ADD-AC #MUD ADD-AC *+10
SUB-AC	SUB-AC 10 SUB-AC X10 SUB-AC MUD SUB-AC %MUD SUB-AC #MUD SUB-AC *+10
MUL-AC	MUL-AC 10 MUL-AC X10 MUL-AC MUD MUL-AC %MUD MUL-AC #MUD MUL-AC *+10
DIV-AC	DIV-AC 10 DIV-AC X10 DIV-AC MUD DIV-AC %MUD DIV-AC #MUD DIV-AC *+10
ADD-IR	ADD-IR 10 ADD-IR X10 ADD-IR MUD ADD-IR %MUD ADD-IR #MUD ADD-IR *+10
SUB-IR	SUB-IR 10 ADD-IR X10 SUB-IR MUD SUB-IR %MUD SUB-IR #MUD SUB-IR *+10
MUL-IR	MUL-IR 10 MUL-IR X10 MUL-IR MUD MUL-IR %MUD MUL-IR #MUD MUL-IR *+10
DIV-IR	DIV-IR 10 DIV-IR X10 DIV-IR MUD DIV-IR %MUD DIV-IR #MUD DIV-IR *+10
AND-AC	AND-AC 10 AND-AC X10 AND-AC MUD AND-AC %MUD AND-AC #MUD AND-AC *+10
OR-AC	OR-AC 10 OR-AC X10 OR-AC MUD OR-AC %MUD OR-AC #MUD OR-AC *+10
LAND-AC	LAND-AC 10 LAND-AC X10 LAND-AC MUD LAND-AC %MUD LAND-AC #MUD LAND-AC *+10
LOR-AC	LOR-AC 10 LOR-AC X10 LOR-AC MUD LOR-AC %MUD LOR-AC #MUD LOR-AC *+10
ABS-AC	ABS-AC 10 ABS-AC X10 ABS-AC MUD ABS-AC %MUD ABS-AC #MUD ABS-AC *+10
AND-IR	AND-IR 10 AND-IR X10 AND-IR MUD AND-IR %MUD AND-IR #MUD AND-IR *+10
OR-IR	OR-IR 10 OR-IR X10 OR-IR MUD OR-IR %MUD OR-IR #MUD OR-IR *+10
LAND-IR	LAND-IR 10 LAND-IR X10 LAND-IR MUD LAND-IR %MUD LAND-IR #MUD LAND-IR *+10
LOR-IR	LOR-IR 10 LOR-IR X10 LOR-IR MUD LOR-IR %MUD LOR-IR #MUD LOR-IR *+10
AND-SR	AND-SR 10 AND-SR X10 AND-SR MUD AND-SR %MUD AND-SR #MUD AND-SR *+10
OR-SR	OR-SR 10 OR-SR X10 OR-SR MUD OR-SR %MUD OR-SR #MUD OR-SR *+10
ABS-IR	ABS-IR
SLA-AC	SLA-AC 10 SLA-AC X10
SRA-AC	SRA-AC 10 SRA-AC X11
SLL-AC	SLL-AC 10 SLL-AC X12
SRL-AC	SRL-AC 10 SRL-AC X13
RROT-AC	RROT-AC 10 RROT-AC X14
LROT-AC	LROT-AC 10 LROT-AC X15
SLA-IR	SLA-IR 10 SLA-IR X16
SRA-IR	SRA-IR 10 SRA-IR X17
SLL-IR	SLL-IR 10 SLL-IR X18
SRL-IR	SRL-IR 10 SRL-IR X19
RROT-IR	RROT-IR 10 RROT-IR X20
LROT-IR	LROT-IR 10 LROT-IR X21
LDN-AC	LDN-AC 10 LDN-AC X10 LDN-AC MUD LDN-AC %MUD LDN-AC #MUD LDN-AC *+10
HALT	HALT 0 HALT 1 HALT 2
JMP-PR-LT	JMP-PR-LT 10 JMP-PR-LT X10 JMP-PR-LT MUD JMP-PR-LT %MUD JMP-PR-LT #MUD JMP-PR-LT *+10
JMP-SR-GT	JMP-SR-GT 10 JMP-SR-GT X10 JMP-SR-GT MUD JMP-SR-GT %MUD JMP-SR-GT #MUD JMP-SR-GT *+10
JMP-SR-EQ	JMP-SR-EQ 10 JMP-SR-EQ X10 JMP-SR-EQ MUD JMP-SR-EQ %MUD JMP-SR-EQ #MUD JMP-SR-EQ *+10
JMP-SR-LT	JMP-SR-LT 10 JMP-SR-LT X10 JMP-SR-LT MUD JMP-SR-LT %MUD JMP-SR-LT #MUD JMP-SR-LT *+10
JMP	JMP 10 JMP X10 JMP MUD JMP %MUD JMP #MUD JMP *+10
JMP-AC-GT	JMP-AC-GT 10 JMP-AC-GT X10 JMP-AC-GT MUD JMP-AC-GT %MUD JMP-AC-GT #MUD JMP-AC-GT *+10
JMP-AC-EQ	JMP-AC-EQ 10 JMP-AC-EQ X10 JMP-AC-EQ MUD JMP-AC-EQ %MUD JMP-AC-EQ #MUD JMP-AC-EQ *+10
JMP-AC-LT	JMP-AC-LT 10 JMP-AC-LT MUD JMP-AC-LT X10
JMP-IR-GT	JMP-IR-GT 10 JMP-IR-GT MUD JMP-IR-GT X10
JMP-IR-EQ	JMP-IR-EQ 10 JMP-IR-EQ MUD JMP-IR-EQ X10
JMP-IR-LT	JMP-IR-LT 10 JMP-IR-LT MUD JMP-IR-LT X10
DISPLAY	DISPLAY 0 DISPLAY 1 DISPLAY 2
READ-NUM	READ-NUM 10 READ-NUM X10 READ-NUM MUD READ-NUM %MUD READ-NUM #MUD READ-NUM *+10
READ-STR	READ-STR 10 READ-STR X10 READ-STR MUD READ-STR %MUD READ-STR #MUD READ-STR *+10
WRITE-NUM	WRITE-NUM 10 WRITE-NUM X10 WRITE-NUM MUD WRITE-NUM %MUD WRITE-NUM #MUD WRITE-NUM *+10
WRITE-STR	WRITE-STR 10 WRITE-STR X10 WRITE-STR MUD WRITE-STR %MUD WRITE-STR #MUD WRITE-STR *+10
LD-AC-ADR	LD-AC-ADR 10 LD-AC-ADR X10 LD-AC-ADR MUD LD-AC-ADR %MUD LD-AC-ADR #MUD LD-AC-ADR *+10
LD-IR-ADR	LD-IR-ADR 10 LD-IR-ADR X10 LD-IR-ADR MUD LD-IR-ADR %MUD LD-IR-ADR #MUD LD-IR-ADR *+10
LD-BR-ADR	LD-BR-ADR *

Directives Return To Top

Label Specification	Mnemonic	Operand Type	Description	Consumes Memory?	Internal Function Number
required label	START	type 1	Indicates the 'start' of a program. This directive requires a label attached to it in column 1.	NO	19
none	END	none	Indicates the 'end' of the program. This directive does not require a label or an operand.	NO	1
optional label	RESET-LC	type 2	This directive resets the location(LC) to the new value assigned in the operand. The value must be greater than the last assigned LC. This directive does not require a label.	NO	2
none	USING	none	Indicates that the program addressing will be relative to the base register(BR). This directives must appear before any instruction or data that consumes memory. This directive does not require a label or an operand.	NO	3
none	DEBUG	On or Off	This directive turns on the debug feature of the simulator. This directive does not require a label.	NO	4
required label	EQU	type 1	This directive equates the label defined to it to as a constant replace value in the operand. This directive requires a label.	NO	5
required label	EQU-EXP	EXPRESSION 1	This directive equates the label to the results of an expression. This directive requires a label.	NO	6
none	ALT-START	ST-BR	This directive allows alternative execution starting point. This directive does not require a label.	NO	7
optional label	SKIP-MEM	type 2	This directive skips a number of words based on the value of the operand.	YES	8
none	ENTRY	"label,label,label,label"	This directive defines local variables in its operand's part as available for reference by another program. Up to 4 operands could be assigned. This directive does not require a label. NOTE: Undefined ENTRY symbols will just be given the value of the Program START. This produces a WARNING.	NO	9
none	EXTERNAL	"ex-label,ex-label,ex-label,ex-label"	This directive declares that the label(s) in the operand's part are external variable references. Up to 4 operands could be assigned. This directive does not require a label.	NO	10
optional label	WORD-NUM	base 10 number right justified	This directive defines a word containing the numeric value of base 10 (decimal), right-justified. Label is optional for this directive.	YES	11
optional label	WORD-CHR	'ccc' left justified	This directive defines a word containing the character string. Up to 3 characters can be assigned, and is left-justified. Label is optional for this directive.	YES	12
optional label	WORD-HEX	hex string right justified	This directive defines a word containing the numeric value of base 16 (hexadecimal), right-justified. Label is optional for this directive.	YES	13
optional label	WORD-BIN	binary string right justified	This directive defines a word containing the numeric value of base 2 (binary), right-justified. Label is optional for this directive.	YES	14
optional label	COMP	EXPRESSION 2	This directive will compute the value of the operands and develops the corresponding assembles code based on the expression value. Label is optional for this directive. NOTE: COMP will produce code for all valid labels assigned to COMP. Ex: "validLabel=invalid+invalud/invalid" will still store the validLabel into the AC.	YES	15
optional label	ADR-COMP	EXPRESSION 3	Address computation. Label is optional for this directive.	YES	16
optional label	ADR	Address constant	This directive defines a word and place the address of the operand in the defined word. Label is optional for this directive.	YES	17
optional label	NOP	none	This directive will generates the instruction " SLA-AC 0". This means No Operation will be done on this line. Label is optional for this directive.	YES	18

Using the TRESSEL SDK Return To Top

The assembler will create an object file for a TRESSEL source code file. The object file is the compiled version of TRESSEL source code.

The linker combines object files together, relocating memory addresses and references in object code. The linker generates a load file from one or more object files.

The simulator executes a load file.

To run a TRESSEL source program, assemble the source file, link its object file, and then load the load file into the simulator.

Running the Assembler Return To Top

1. Write TRESSEL source code in a text editor. Save the source code file to the same folder as the assembler.
2. Ensure the files "instructions.txt", "directives.txt", and "errors.txt" are in the assembler folder. These files represent the instructions, directives, and error tables, respectively, and are required for the assembler to work.
3. Run the assembler, Console.exe, and type the name of your source code file when prompted. Press ENTER.
4. The assembler will display the symbol table and the assembly listing. Errors will be printed below the line of source they occured on.
5. The output files have the same filename as the input file with the extensions ".int.txt", ".sym.txt", ".obj.txt", ".results.txt". The OBJ file is the object file. INT is the intermediate table generated by pass 1 of assembly. SYM is the symbol table. RESULTS is the list of errors for the source code.

Running the Linker Return To Top

1. Assemble one or more TRESSEL source programs into object files with the assembler. Move their object files from the 'AssemblyFiles' folder to the 'LinkerFiles' folder.
2. Ensure the file "linkerrors.txt" is in the linker folder. This file contains all of the linker's error messages.
3. Run the linker, Linker.exe, and type the names of your object files separated by spaces when prompted. Press ENTER.
4. The linker will display the contents of each object file it loads. Errors will be printed below the line of the file they occurred on. After it processes each object file, it will display the contents of the load file as it is generated. Any errors found while creating the load file will appear below the respective load record.
5. The linker will display the linker symbol table, load file memory map, and operation summary. Press any key to end the linker.
6. The load file saved by the linker will have the name of the first module loaded plus ".load.txt". This is the file that can be loaded by the simulator.

Running the Simulator Return To Top

1. Link all necessary modules using the Linker.exe, and produce the ".load.txt" file required for simulation.
2. Since all error messages are generated inline within the program, all you need is the Simulator.exe and your load file, created using the Linker.exe.
3. Run the simulator, Simulator.exe, and type the name of your load file when prompted. Press ENTER.
4. The simulator will display the a hex echo of the data being stored into memory. Additionally, any input requested, through either a READ-NUM or READ-STR will be requested. Follow the prompts. Output will also be displayed, from calls either to WRITE-NUM, WRITE-STR, or DISPLAY. If any errors are fouind during execution, those will also be displayed on-screen.
5. The simulator will display everything listed above. Press any key to end the simulation process.
6. The output file saved by the simulator will have "out." followed by the name of the module loaded plus ".txt". This file contains both before and after execution hex dumps, and any register values requested through the DEBUG feature.

Sample Program and Output Return To Top

Program Name	Objective	Source File	Results File	Symbol Table File	Intermediate File	Object File	Load File
Cham	Calculate X^2 + Y^2 then store result into memory.	Cham.txt	Cham.results.txt	Cham.sym.txt	Cham.int.txt	Cham.obj.txt	Cham.load.txt

Step One - Assembling Cham
Sample Assembler

Step Two - Linking Cham

Step Three - Simulating Cham
Sample Simulator

This is one of our test cases we ran during testing of our Assembler. The first file, listed under the "Source File" header, is simply the '.txt' TRESSEL source code we wanted to run in our compiler. The '.results.txt' is an output of errors that were found upon running the test case. The '.sym.txt' is a file containing our sorted symbol table, including all literals, EQUs, symbol/label declarations, and the program name. The '.int.txt' is our intermediate source output. The '.obj.txt' is the Object file which is what is linked. The '.load.txt' is the load file which is the load file for this program created by the linker. The 'out.[filename].txt' is the hex dump output from the simulator.

Intermediate source format:
Line#=nn|LC=nn|label=ccccc|opc=cccccccc|operand1=ccc|operand2=ccc|operand3=ccc|operand4=ccc|binary-�‐
opc=bbbbbbb|literal=cccccc|IR=c|AR=c

Where 'c' is a representation of a character we inputted into the intermediate file.

The object file contains a header record, linking record(s), text record(s), and an end record. The header record contains information about the program. Linking records describe symbols used when linking to other programs; there is one linking record for each entry directive. Text records describe object code. There will be a Text Record for any instruction or directive that consumes memory, besides ALT-START and SKIP-MEM. The object file is finalized by the End record which contains a count of the types of records.

Object file record formats:
HEADER:
H | Module name | Date {yyyy:ddd} | Time {hh:mm:ss} | program length in HEX (n of wds) {hhhh} | assembler assigned program load address in HEX {hhhh} | Number of linking records in H {hhhh} | Number of Text Records in HEX {hhhh} | Execution start address for this module {hhhh} | TRESSEL | Version # | Revision #

LINKING:
L | Entry Name | Entry Address in HEX | Module Name

TEXT:
T | Address in hex {hhhh} | Code/data Word {hhhhhh} | Relocation Type for S1 A or R or C or B {c} | + OR -� | S1 Referenced Symbol Name | Relocation Type for S2 A or R or C or B {c} | + OR -� | S2 Referenced Symbol Name | Relocation Type for S3 A or R or C or B {c} | + OR -� | S3 Referenced Symbol Name | Module Name

Where Relocation Types: A = Absolute addressing, B = Base Relative addressing, R = Start Relative addressing, and C = Complex.
Relocation type C records will include a series of + or - operators followed by symbol names after the relocation type. These are fields for adjustment by specific symbols to be done by the linker. Symbols shown here will either be a program name or an external symbol.

END:
E | Total Number of Records H+L+T+E in hex {hhhh} | Module Name

Load file record formats:
HEADER:
LH | First Module Name | Start Address {hhhh] | Length {hhhh} | Load Address {hhhh} | Date | Time | TRESSEL-LINK | Version | Revision

TEXT:
LT | Load Address {hhhh} | Object Code {hhhhhh} | Originating Module Name

END:
LE | Total Number of Records LH+LT+LE in hex {hhhh}

Compile through Execution Return To Top

To view our C++ code, or perhaps run our assembler from an Integrated Development Enviornment (IDE) rather than the console, open up the 'AssemblyFiles' folder. Inside that will be several files: "Console.exe" "SourceCode.cpp" "SP2.vcproj" "instructions.txt" "errors.txt" and "directives.txt". Double-click on the "SP2.vcproj" to open up our project. We coded ours using the Microsoft Visual Studio 2008 IDE. Once the window opens up, go to the drop-down option presently labeled 'Debug,' and change it to release. Once you do that, go directly to the left and press the small green arrow, executing the file. Or simply press F5. Continue by entering your filename into the console, including the file extension, and then strike the Enter key.

To open the source code of the linker, open up the 'LinkerFiles' folder and then open the "SP3.vcproj" to open the linker project.

Load and Execution of TRESSEL Programs Return To Top

Upon inserting the CD (or downloading the .zip online), right-click on the .zip and select Extract-All and extract the files to your desktop. Inside the folder should be the following folders:
- AssemblyFiles
- LinkerFiles
- SimulatorFiles
- Documentation

To compile and assemble your source file, enter the folder named 'AssemblyFiles'. Refer to "Running the Assembler" to learn what to do next to assemble your TRESSEL source program. If you need to modify the directives, instructions, or error listings, the corresponding .txt files are also located in this folder.

To link your object files, enter the folder named 'LinkerFiles'. Refer to "Running the Linker" to learn what to do next to link.

To simulate your program, enter the folder named 'SimulatorFiles'. Refer to "Running the Simulator" to learn what to do regarding the simulation of your program and the testing of your TRESSEL program's logic.

To view documentation, double-click on the 'Documentation' folder, and then open up the "index.html" in a browser. Most of your questions can be answered there.

**NOTE**
The executables included in the TRESSEL SDK, Console.exe, Linker.exe, and Simulator.exe are only ensured to run in the Microsoft Windows XP and Vista environments. Our SDK is not guaranteed to work properly on any other platform.

Assembler Error Messages Return To Top

Error Number	Message/Cause	Correction
1	File could not be found. FATAL	Either you mis-typed the source filename or one of the table files is missing (instructions.txt, directives.txt, or errors.txt).
2	Label has already been used.	The label is already in the symbol table, change the label name so it doesn't repeat the previous one.
3	Labels must not exceed 64 characters.	Labels can only be 64 characters max, shorten the label name.
4	Labels must begin with a letter.	Labels are alphanumeric and the first character must be a letter. Change the first character.
5	Labels may only contain letters and numbers,or a dash, underscore, or period.	Labels can only contain letters and numbers, or a dash, underscore, or period. Get rid of the extraneous characters.
6	Labels must contain at least 2 characters.	Labels have a minimum length of 2 characters, make the label longer.
7	First line must start with a label in column 1.	The program name declaration must start in column 1 of the first line.
8	Program must begin with a START directive on line 1. FATAL	Make sure your START line of code is in line 1 and only line 1.
9	Comments must begin with a ':' character.	Probably an invalid comment. Make sure every comment is led with a colon (':').
10	Start location must be between 0 and end of program memory. FATAL	Your starting position in memory must be contained within the total memory allocation of the program. (Maximum limit of 0-4095).
11	Invalid operands.	Very general. But if you recieve this error, there is some form of an issue with your operands token on the specified line. Make sure your syntax is correct.
12	Directive cannot have a Label. FATAL	The directive that this label was attached to is not allowed. The directive requires no label. This is a fatal error because elsewhere in the code, you may have made reference calls to this label, which would cause furthermore complex errors.
13	Operation not recognized.	The operation token specified on the line was not a recognized Instruction or Directive. Make sure you spelled it correctly.
14	Directive cannot follow an instruction.	You listed two operations on one line. This is not allowed. Remove either the instruction or the directive.
15	Cannot have multiple instructions on one line.	You listed multiple instructions on one line. You can only have one; remove all extraneous calls.
16	Directive requires a label.	The directive on this line requires a label, add one in on column 1 of the line.
17	Cannot have multiple directives on one line.	You listed multiple directives on one line. You can only have one; remove all extraneous calls.
18	Instruction cannot follow a directive.	You listed two operations on one line. This is not allowed. Remove either the instruction or the directive.
19	Duplicate START Directive	START may only be called in the first line of your program. Remove this additional line from your source code.
20	END has operands specified when no operands expected	END should have no operands. The only thing following this should either be a comment or nothing. Remove all extraneous operands.
21	Invalid LC: must be greater than current LC	When calling RESET-LC, the Location Counter must be greater than the current value. Make sure you move somewhere forward in the code, not backwards.
22	USING has operands specified when no operands expected	USING takes no operands. Simply remove all extraneous operands.
23	word-num requires base 10 number as operand	The passed in parameter must be in base 10 (decimal). Make sure the operand only has numeric characters.
24	DEBUG operand must be ON or OFF	The operand call for debug must either be an 'ON' or 'OFF.' (case-insensitive). Make sure the operand is one of those two words, and only that.
25	ALT-START address must be in range of program	Your alternate starting position in memory must be contained within the total memory allocation of the program. (Maximum limit of 0-4095).
26	SKIP-MEM address must be in range of program	Your SKIP-MEM memory allocation must be contained within the total memory allocation of the program. (Maximum limit of 0-4095).
27	COMP expression is malformed, please check format	Remember, COMP's operands must be led with a "variable=blah+blah-blah/blah" Make sure you're following proper syntax with the operands, especially leading negatives.
28	word-chr limits to a maximum of 3 characters as an operand	WORD-CHR can only store three characters at a maximum, make sure that, within the single-quotes, you have 3 characters or less.
29	word-hex requires a hexadecimal string as operand	A hexadecimal format implies that characters can only contain numbers 0-9 or letters A-F. Make sure you're following this standard for the operands. Don't include a hexadecimal typecast leader such as '0x' or 'H.'
30	word-bin to a maximum of 24 bits	WORD-BIN operand calls have a limit of 24 characters. Make sure that you have 24 characters or less in the operands field.
31	word-chr may only contain alphanumeric characters	Make sure that within the single-quotes, only letters or numbers are contained. If that's not the case, remove extraneous characters.
32	word-bin must be in binary format (0 or 1)	WORD-BIN operand calls maybe only contain 1's or 0's. Make sure these are the only two character possibilities within the operands field on this line.
33	word-hex must be in hexadecimal format (0-9 or A-F)	A hexadecimal format implies that characters can only contain numbers 0-9 or letters A-F. Make sure you're following this standard for the operands. Don't include a hexadecimal typecast leader such as '0x' or 'H.'
34	number is too large to store	The number is larger than 2^23 or smaller than 2^-24. Make sure that your number value falls within this range, and not outside.
35	literal character strings limit to a maximum of 3 characters	Literals may only have a maximum of 3 characters. Make sure it's no any larger than three.
36	Invalid number encountered when evaluating expression; token ignored	This is an intermediate error, but make sure all operands are either valid labels or valid numbers, and nothing else.
37	Error evaluating expression	This is a general error, But please make sure your operands on the EQU-EXP are all valid and syntactically correct.
38	Error evaluating expression: operators require 2 operands	When calling EQU-EXP, there must be an expression to evaluate, make sure theres at least two or more operands and at least one operator so we may compute. If no computation is needed, make a call to EQU rather than EQU-EXP.
39	Error evaluating expression: multiple results. Check every arithmetic operator has 2 operands.	Make sure for every arithmetic operator (+-/*) there are two operands to compute with. Just make sure your computation logic on this line makes sense.
40	Operand in expression is not number or symbol equated to number; operand is set to 0	There are some invalid operands, make sure they are all numbers or symbols equated to numbers. Remove extraneous operands.
41	Equated expression result is outside addressable range; equate ignored	Make sure the equated expression falls, in memory, between the beginning (the START allocation) and the final location counter at the end of the TRESSEL source.
42	Using directive must be used before any instructions are processed. FATAL	Making sure the call to USING is the very first call after the START, and at location counter 0. If it is not, be sure to move it there. Otherwise, you'll continue to recieve fatal errors.
43	LD-BR instruction must immediately follow a USING directive. FATAL	After the USING had been declared properly, as stated in error 42's explanation, this LD-BR must follow directly after, or you will also get a fatal error. Be sure this comes right after the USING.
44	Instructions cannot follow a HALT command. FATAL	Once the HALT command is called in your TRESSEL source, no Instructions may follow after. Skim through your code and make sure that all instructions are before the call to HALT.
45	Expecting 'ON' or 'OFF" for an operand	The only operands allowed for a call to DEBUG are 'ON' or 'OFF' (case in-sensitive). Make sure you are calling one of these correct operands, and not something else.
46	Expecting "IR' after the comma in the operand	If a comma is within the operands token, it implies that an IR is to follow. When this error is thrown, it means an IR wasn't found. Be sure to either add the IR if it was intended, or remove the comma from the operands token on this line.
47	The Operand Type (Reference) does not allow (#Reference)	This operation, with a reference operands type, does not allow for absolute address referencing. Either change the operation, or remove the # symbol.
48	The Operand Type (Reference) does not allow (%Reference)	This operation, with a reference operands type, does not allow for indirect address referencing. Either change the operation, or remove the % symbol.
49	Instruction requires operands.	This error is caused because you forgot to enter the required operands for this line of code. Either add the specified operands, or remove the line.
50	The Operand Type (Reference-Exp) has to start with a and is followed by + or - followed by a constant or equ'ed symbol	A current reference expression requires an asterisk follow by a plus '+' or minus '-.' You need to check your syntax for the expression call, and make sure all required characters are included.
51	The Operand Type (type 4) only allows a number or equated symbol in the range 0-23	"type 4" reference implies the number/equated symbol must be in range of 0-23. Check the value and make sure it's within the designated range, and not beyond the limitation.
52	The Operand Type (type 1) only allows numbers of range (0~4095 inclusive)	"type 1" reference implies the number must be in range of 0-4095. Check the value and make sure it's within the designated range, and not beyond the limitation.
53	The Operand Type (type 2) only allows numbers or EQUed symbols of range (0~4095 inclusive)	"type 2" reference implies that the number/EQUed symbol must be in range of 0-4095. Check the value and make sure it's within the designated range, and not beyond the limitation.
54	The Operand Type (type 3) only allows a number or equated symbol in the range 0-2	"type 3" reference implies the number/EQUed symbol must be in range of 0-4095. Check the value and make sure it's within the designated range, and not beyond the limitation. Also make sure this is coupled with a HALT operation call.
55	The Entry and External directives only allow total of four Symbols at most.	Entry and External only allow a declaration of, at max, four Symbols. If you need to declare more, simply make multiple Entry/External calls on seperate lines.
56	The word-num directives only allow base 10 numbers	A call to word-num only allows numerics (0-9), make sure there are no extraneous characters within the operands token.
57	An Expression can have at most 4 operators	Expressions may only contain at max four operators within the operands token. If there are too many, be sure to remove some, and prehaps decouple it to another, seperate Expression call.
58	Multiple equal signs in one expression	Within an Expression call, there may only be one equals sign ('='). We can only store the computation into one symbol. Make sure, within your computation logic and syntax, that this is the case.
59	Can only store values in a Symbol	Make sure that when you're storing a value from a COMP expression, that it is being stored into a valid symbol or address. You cannot store a value into another constant value.
60	On Adr-COMP. The expression can contain local labels, external labels, on constants.	ADR-COMP expressions can only contain local/external labels and constants. Make sure theres are the only things within the operands token. If there are any extraneous values; remove them.
61	Labels cannot have their own lines.	If you declare a valid label, it must be followed by an operation call, whether it be a Directive or Instruction. Either remove the label or add a call to an operation.
62	Directive requires an operand.	The Directive you made a call to on this line requies some operands. Either add the required operands to the line, or remove the Directive call.
63	Directive cannot have an operand.	The Directive you made a call to on this line requies no operand. Either remove the listed operand/s from the line, or remove the Directive call.
64	Cannot access memory out of bounds of the program memory.	The address value for this instruction or directive referred to a memory location outside of the current source program, i.e. before the start or after the end of the program. Check your source code.
65	Warning. Labels should start in column 1.	This is simply a warning. Syntax lists that labels should always start in column 1 and only column 1. Your code will still execute, but it is still suggested to move it to the first column.
66	This directive requires a label. FATAL	The directive called on this line has a "rl" typecast for labels. Without this label, calls cannot be made to reference this line. Please add a label or your code will not execute.
67	Warning. Directives should start in column 2 or later.	This is simply a warning. Syntax lists that directives should always start in column 2 or greater. Your code will still execute, but it is still suggested to move it out of the first column.
68	Warning. Instructions should start in column 2 or later.	This is simply a warning. Syntax lists that instructions should always start in column 2 or greater. Your code will still execute, but it is still suggested to move it out of the first column.
69	This directive cannot have a label	The Directive you made a call to on this line cannot have a label. Either remove the listed label from the line, or remove the Directive call.
70	Cannot reference a symbol as an operand if it hasn't been declared.	The symbol you used as an operand is not declared anywhere else in the program, and our assembler does not know what value to use. Resolve this label declaration.
71	Literal not stored inside the symbol table.	The literal that has been called to in this operand is not stored within the symbol table. Make sure the WORD-NUM declared for the literal is pooled at the end.
72	This equated symbol has not been declared for use.	This call to the EQU operand, has no initial declaration. Either initialize the EQU, or remove the call and simply use a constant value instead.
73	The Operand Type (comma delimited list) requires a label for each comma	This is either an ENTRY or EXTERNAL; the format must be label,lablel,label,label. Using 1 to 4 labels, do not add a comma to the end of you operands unless you are adding an additional label.
74	Program cannot exceed system memory. (4095 words)	You cannot reference or branch out of the 4095 words of memory. Make sure all calls are within the specified range of the machine.

**NOTE: If the error message does not literally print the word 'Warning' or 'FATAL,' then it is an intermediate error, and will simply remove that source line from execution.

Linker Error Messages Return To Top

1	Execution start address is smaller than the assembler assigned program load address	Change the value in Execution start address (9th column) in Header Record to something smaller than assembler assigned program load address (6th column) in header rec
2	Missing Symbol	Add a symbol after the relocation type and the sign (+ or -)
3	TRESSEL is missing in the 10th column	Add the word "TRESSEL" in the 10th column of the Header Record
4	A vertical bar '\|' is required after the Version number	Insert a vertical bar '\|' after the version number in Header Rec
5	A vertical bar '\|' is required after TRESSEL in header record	Insert a vertical bar '\|' after the word "TRESEEL" in Header Rec
6	Address has to be a 4-digit-hex	Make sure that the address column in Text Record has a valid hex number with 4 digits
7	A vertical bar '\|' is required after the Address	Insert a vertical bar '\|' after the address column in Text Record
8	CODE/DATA Word has to be a 6-digit-hex	Make sure that the CODE/DATA WORD column in Text Record has a valid hex number with 6 digits
9	A vertical bar '\|' is required after the Code/Date Word	Insert a vertical bar '\|' after the CODE/DATA WORD column in Text Record
10	A vertical bar '\|' is required after the Relocation type	Insert a vertical bar '\|' after the Relocation type column in Text Record
11	The first Relocation type is invalid or missing	Make sure there is at least one valid Relocation type in the Relocation type column
12	A vertical bar '\|' is required after the '+' or the '-' sign	Insert a vertical bar '\|' after the '+ or - sign' column in Text Record
13	# of Text Records is greater than the Length of the Module	Check if the 'number of text records' column has greater value than the 'program length' column does in the Header Record
14	The length of a Symbol has to be at least 2	Check if any of the Referenced symbols in the Text record less than one character long
15	A Symbol may only contain alphabets, numbers, hyphens, underscores, and periods	Make sure that all of the Referenced symbols in the Text record contain only alphabets, numbers, hyphens, underscores, and periods
16	A Symbol must begin with an alphabet	Make sure that all of the Referenced symbols in the Text record start with an alphabet (Aa~Zz)
17	Module name is missing or invalid	Make sure the record has a valid module name at the end
18	Address must be in the range 0~4095	Make sure the Address does not go over 4095 or below 0 in decimal. Note that it is treated as a hex number
19	The total number of records is incorrect	Make sure that the Total Number of Records column in the End Record is correct
20	The Execution start address for this module must be a 4-digit-hex	Check the Execution start address in the Header Record; it's either containing invalid hex digits, less than 4 digits, or both
21	The Number of Text Records must be a 4-digit-hex	The Number of Text Records column in the Header Record is invalid; it's either containing invalid hex digits, less than 4 digits, or both
22	A vertical bar '\|' is required after the Number of Linking Records	Insert a vertical bar '\|' after the Number of Linking Records column
23	A vertical bar '\|' is required after the Number of Text Records	Insert a vertical bar '\|' after the Number of Text Records column
24	The Number of Linking Records must be a 4-digit-hex	The Number of Linking Records column in the Header Record is invalid; it's either containing invalid hex digits, less than 4 digits, or both
25	A vertical bar '\|' is required after the Assembler Assigned Program Load Address	Insert a vertical bar '\|' after the Assembler Assigned Load Address
26	Entry symbol used as an External	Make sure that the referenced symbols after 'C\|+\| ' format is external and not entry
27	The Assembler Assigned Program Load Address must be a 4-digit-hex	The Assembler Assigned Program Load Address column in the Header Record is invalid; it's either containing invalid hex digits, less than 4 digits, or both
28	The program length has to be in the range 0~4095	Make sure the program length does not go over 4095 or below 0 in decimal. Note that it is treated as a hex number
29	The program length must be a 4-digit-hex	Make sure that the program length column in Header Record has a valid hex number with 4 digits
30	Check Time(seconds)	The Seconds section in Header Record is not in the range of 0~59
31	Check Time(minute)	The Minutes section in Header Record is not in the range of 0~59
32	Check Time(hour)	The Hour section in Header Record is not in the range of 0~23
33	A colon ':' is required after hour(dd)	Add a colon ':' after the hour section in the Header record; make sure it's two digits long
34	A colon ':' is required after minute(dd)	Add a colon ':' after the minute section in the Header record; make sure it's two digits long
35	A vertical bar '\|' is required after second(dd)	Add a vertical bar '\|' after the seconds section in the Header record; make sure it's two digits long
36	A vertical bar '\|' is required after date(ddd)	Add a vertical bar '\|' after the Date section in the Header record; make sure it's THREE digits long
37	A vertical bar '\|' is required after the Program Length	Add a vertical bar '\|' after the program length column in the Header record
38	The Date out of range (0~364)	Make sure the date is in the range from 0 to 364
39	The Date must be a 3-digit-decimal	Make sure date has THREE digits
40	A colon ':' is required after year(dddd)	Add a colon ':' after the year section in the Header record; make sure it's FOUR digits long
41	The Year must be a 4-digit-decimal	Make sure the year is four digits long
42	A vertical bar '\|' is required after the Execution start address	Insert a vertical bar '\|' after the Execution start Address
43	A vertical bar '\|' is required after 'H', 'L', 'T', or 'E'	Insert a vertical bar '\|' after the record type indicator (the very first column for every record types)
44	Source file cannot be found.	Check for the input source filename; then check if that file exists in the same directory as the linker
45	Object file must begin with Header record. Module ignored.	The first record in the object file should be a header record
46	Not enough space left in memory to load this module. Module ignored.	Previous modules consumed memory too much that it was unable to load this module; remove unnecessary words to preserve memory for this module
47	Linking record does not belong to this module. Record ignored.	Check and make sure the last column (module name) corresponds to the module name in the Header Record
48	Symbol on linking record already exists in load file. Record ignored.	Change the symbol name in this linking record; you may change the duplicate symbol declared as an ENTRY in one of the previous object files loaded
49	Invalid record.	The first column of every record types should be either 'H', 'E', 'L', or 'T'
50	Object file must end with End record. Unable to verify record count.	Add an END record at the end of the object file
51	Linking record count reported by Header record is incorrect.	Make sure that the Number of Linking Records column in the Header Record is correct
52	Text record count reported by Header record is incorrect.	Make sure that the Number of Text Records column in the Header Record is correct
53	Record count reported by End record is incorrect.	Make sure that the Total Number of Records column in the End Record is correct
54	Symbol on header record already exists in load file. Module ignored.	The current module's name is declared either as an ENTRY or as a Program Name in another object file
55	End record does not belong to this module.	The Module name in the last column of the End Record does not match the current module's name in the Header Record
56	not used***	UNUSED
57	No load file will be generated as no modules were linked successfully.	Was not able to find a single correct object file. Correct all the errors listed in the output
58	Relocation type R accepts only the current module name as relocation symbol. One relocation symbol ignored.	Whereever there is a 'R\|+or-\|' format, make sure the following symbol matches the current module's name in the header record
59	Relocation operator must be either '+' or '-'. One relocation symbol ignored.	There must be either a + or - sign after the relocation type column except for the first relocation type if it's not C
60	The number of records has to be a 4 digit hex	Make sure that the total number of records column in End Record has a valid hex number with 4 digits
61	A vertical bar '\|' is required after the Total Number of Records	Insert a vertical bar '\|' after the Total Number of Records column in the End Record
62	Relocated object code address exceeds addressable range. Object code not relocated.	The hex-value address stored in the object file is outside the range of valid memory. Make sure the hex code has not been tampered with and fits within 0-2048
63	Relocated object code address refers to location before load file. Object code not relocated.	The hex-value address stored in the object file is before the range of valid memory within the program module. Make sure the hex code has not been tampered with and fits within the specified program range.
64	Relocated object code address refers to location after load file. Object code not relocated.	The hex-value address stored in the object file is after the range of valid memory within the program module. Make sure the hex code has not been tampered with and fits within the specified program range.
65	Relocation type C accepts only an external as relocation symbol. One relocation symbol ignored.	The Referenced symbol has not been declared in other object files as an ENTRY
66	Relocation type C requires an operator and a symbol.	Insert either a + or - sign after every C relocation type

Simulator Error Messages Return To Top

Error Number	Message/Cause	Correction
1	Program name must begin with an alphabetic character.	The module name listed in the Linker Header Record does not match proper format. Specifically, the first character must be a valid letter.
2	Program name length must within 2 to 64 characters length.	The module name listed in the Linker Header Record does not match proper format. Specifically, the name is either only one character long, or beyond 64 characters.
3	Program name must only contain alphanumerics, periods, dashes, or underscores.	The module name listed in the Linker Header Record does not match proper format. Specifically, the name may only contain letters, numbers, periods, dashes, or underscores.
4	Linker Header Record has improper format (Make sure vetical bars (\|) are properly placed).	The linker header record is mis-formatted. You are missing vertical pipes somewhere on the line, make sure all bars required, are present.
5	Program Initial Start value is not within valid memory (0-4095).	The initial start value of memory for the load file is not within valid range, make sure the entire program fits within 0-4095 words.
6	Program Execution Start value is not within valid memory (0-4095).	The execution start value of memory for the load file is not within valid range, make sure the ALT-START value is within valid range of 0-4095.
7	Program Length exetends beyond bounds of memory (using Initial start value).	The length of the program, added to the initial start value, exceeds beyond 4095 in memory. Either re-adjust the start value, or shrink the length of the program.
8	Load file could not be found.	The load file name was no recognized. Make sure the file is within the same directory, and that you type in the filename properly.
9	Linker Text Record has improper format.	The linker text record on this line has improper format. You are likely missing vertical pipes; make sure that wherever one is specified to exist, it is actually there within the load file.
10	Given Hex Code cannot be recognized. Must be A-F (case insensitive) or 0-9.	The given hex-code must be either 0-9 or A-F. Make sure the load file has not been modified improperly.
11	Linker End Record has improper format.	The linker end record on this line has improper format. You are likely missing vertical pipes; make sure that wherever one is specified to exist, it is actually there within the load file.
12	Number of Records stored in Linker End Record does not match the iterated amount.	The number of records within the load file does not match the listed number within the linker head record. Execution will still continue though there is more than likely some serious issue, or a mis-type in the total number of records on the linker head record filing.
13	Unable to recognize this record.	This record has improper format. All records either begin with LH, LT, or LE. If a specific record does not follow this format, you will recieve this error. Make sure all syntax is correct in the load file.
14	Linker Head Record was not found.	The Linker Head Record was not found, and we therefore cannot determine vital program information. Make sure the LH line is contained within the load file.
15	Linker End Record was not found.	The Linker End Record was not found, and we therefore cannot determine vital program information. Make sure the LE line is contained within the load file.
16	Failed to load instruction: "hexCode" at memory location "hexLoc" (Invalid location).	The memory location (in hexadecimal) specified by the Linker Text Record is invalid. Make sure the 4 digit hex value was not modified and fits within the range of the program's memory (0-4095).

**NOTE: Beware if the error you received says something was ignored. This means the module, record, or symbol was skipped because it had an error.

Software Limitations Return To Top

- Declarations of WORD-CHR cannot contain ANY Whitespace; tabs (\t) or spaces (" ").
--- FIXED Nov. 16th, 2009 ---

- Source code has a limitation of 900 characters per line. If it exceeds this, the remaining portion of the comment simply won't be outputted in the console.

- If an error is found on a line of source code, either parsing will stop on that line or the line will become a NOP instruction, depending on whether the error was detected in Pass 1 or Pass 2 of the assembler. Because of this, the assembler will not go on to check for more errors. This will lead to cases where fixing an error on a line of source code will lead to a different error; although there were always 2 errors for that line, the second error was never detected because the parser skipped the remaining assembly for that line after the first error.

Written by Group 3 of CSE 560 Autumn 2009 5:30 section
Chris Brainerd, Jarrod Freeman, Abe Kim, Abdul Modrokbi, David Straily, and Alvin Stutz
The Ohio State University