• To ensure the interface is compatible during the group deliverable: The program have three main high-level function with their interfaces shown as below:

  • ParseOperands:DataPath->Token List-><self-define operand type>
  • ParseInstr:DataPath->LineData->Result<Parse<Instr>,string> option
  • Execution:DataPath->Parse<Instr>->DataPath

• The overall interface is shown in the flow chart below:

• The following functions are compatible with other group members' module and can be conveniently adopted with little modification:

• Flexible Second Operand(FlexOperand2) is calculated as uint32, before being parsed to parse<Instr> ;SetC is parsed as bool option representing the C flag update status when calculating FlexOperand2.
• For Rs during shift operations, only the least significant byte is used and can be in the range of 0-255.
• For #n during shift operations, only the least siginificant 5-bits are used and can be in the range of 0-31, this feature is not implimented in VisUAL, the reasoning is to eliminate redundant number of shift(#n).
• The immediate literals are tested to be creatable by rotating a 8-bit number right within a 32-bit word.
• Updating Flags:

  • Shift Operations:The C flag is updated to the last bit shifted out, except when the shift length is 0. N and C are updated according to the result.

  • Bitwise Operations & mov/mvn & tst/teq:The C flag can be updated during the calculation of the FlexOperand2. N and C are updated according to the result.

• ParsesomeOperationOps: parse Token List to self-defined operand type with additional input of DataPath
• tokenize: string->token List: tokenize a string of all operands to token List
• FlexOp2: DataPath->FlexOp2->uint32: calculate the flexible second operand as uint32
• Op2SetCFlag: DataPath->FlexOp2->bool option: return the C flag status updated when calculating FlexOp2

• ShiftExecute: DataPath->Parse<Instr>->DataPath: execute shift operation and update the DataPath
• updateFlRegs: update flag and register contents after an operation
• CheckCond: DataPath->Condition->bool: check whether the flags matches the condition for conditional operation
• SFparse: parse LineData to Result<Parse<Instr>,string> option with additional input of DataPath

• BitwiseExecute: DataPath->Parse<Instr>->DataPath
• updateFlRegs
• BTparse

• TestExecute: DataPath->Parse<Instr>->DataPath
• updateFlRegs
• TTparse

• MovsExecute: DataPath->Parse<Instr>->DataPath
• updateFlRegs
• MVparse

The Tests are desgined as unit tests with randomized initail states under VTest.fs

• The specific Test method is as following:
  • Generate random initial R0-R14 register contents;
  • Generate random initial NZCV Flags;
    • fail with Error when N and V are both true.
  • Initialise assembly instructions covering all realised operations and operation modes;
  • Feed the above initial states as DataPath and LineData in to F#'s someExecution:DataPath->Parse<Instr>->DataPath;
  • Input the initial states as Params and string to visUAL RunVisualWithFlagsOut->Params->string->Flags->VisOutput;
  • Test the output states for F# assembler and visUAL are equal, namingly the updated register contents and the updated flags are equal .

The four types of operations are represented as symbols:

The specific unit tests and their status are as following: