TRESSEL User's Guide

TRESSEL Documentation > TRESSEL User's Guide

Table of Contents

-- 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 range of 0 to 2047. Does not support the use of parantheses.
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
Sample Linker
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