From 98d09c1074ae808d03c35ed7edefa335fd107012 Mon Sep 17 00:00:00 2001 From: Pablo Parra Date: Sat, 9 Dec 2017 16:31:06 -0800 Subject: [PATCH] Added ALU events Also, minor fixes: - Fixed the register pointes on the memory view component. - Fixed the horizontal overflow and text wrapping on the events log viewer component. --- src/app/alu.ts | 100 ++++++- src/app/cpu.service.ts | 3 +- .../events-log-viewer.component.html | 2 +- .../events-log-viewer.component.ts | 8 + src/app/memory-view/memory-view.component.ts | 275 +++++++++--------- src/styles.css | 3 +- 6 files changed, 248 insertions(+), 143 deletions(-) diff --git a/src/app/alu.ts b/src/app/alu.ts index 8e7e965..f499582 100644 --- a/src/app/alu.ts +++ b/src/app/alu.ts @@ -1,6 +1,9 @@ import { CPUStackPointerRegister, CPUStatusRegister, CPURegister, CPURegisterIndex } from './cpuregs'; +import { Utils } from './utils'; +import { EventsLogService, SystemEvent } from './events-log.service'; + export enum ALUErrorType { DIVISION_BY_ZERO = 0 @@ -115,7 +118,7 @@ export interface ALUOperationParamsBitshiftOp { } -export class ALUOperation { +export class ALUOperation implements SystemEvent { public operationType: ALUOperationType; public data: any; @@ -127,6 +130,99 @@ export class ALUOperation { } + toString(): string { + + let ret, params; + + switch (this.operationType) { + case ALUOperationType.ADD: + params = this.data; + ret = `ALU: 16-bits addition (0x${Utils.pad(params.summand1, 16, 4)} + 0x${Utils.pad(params.summand2, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.ADDB: + params = this.data; + ret = `ALU: 8-bits addition (0x${Utils.pad(params.summand1, 16, 2)} + 0x${Utils.pad(params.summand2, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SUB: + params = this.data; + ret = `ALU: 16-bits substraction (0x${Utils.pad(params.minuend, 16, 4)} - 0x${Utils.pad(params.subtrahend, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SUBB: + params = this.data; + ret = `ALU: 8-bits substraction (0x${Utils.pad(params.minuend, 16, 2)} - 0x${Utils.pad(params.subtrahend, 16, 2)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.MUL: + params = this.data; + ret = `ALU: 16-bits multiplication (0x${Utils.pad(params.multiplicand, 16, 4)} * 0x${Utils.pad(params.multiplier, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.MULB: + params = this.data; + ret = `ALU: 8-bits multiplication (0x${Utils.pad(params.multiplicand, 16, 2)} * 0x${Utils.pad(params.multiplier, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.DIV: + params = this.data; + ret = `ALU: 16-bits integer division (0x${Utils.pad(params.dividend, 16, 4)} * 0x${Utils.pad(params.divisor, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.DIVB: + params = this.data; + ret = `ALU: 8-bits integer division (0x${Utils.pad(params.dividend, 16, 2)} * 0x${Utils.pad(params.divisor, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.AND: + params = this.data; + ret = `ALU: 16-bits bitwise AND (0x${Utils.pad(params.operand1, 16, 4)} & 0x${Utils.pad(params.operand2, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.ANDB: + params = this.data; + ret = `ALU: 8-bits bitwise AND (0x${Utils.pad(params.operand1, 16, 2)} & 0x${Utils.pad(params.operand2, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.OR: + params = this.data; + ret = `ALU: 16-bits bitwise OR (0x${Utils.pad(params.operand1, 16, 4)} | 0x${Utils.pad(params.operand2, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.ORB: + params = this.data; + ret = `ALU: 8-bits bitwise OR (0x${Utils.pad(params.operand1, 16, 2)} | 0x${Utils.pad(params.operand2, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.XOR: + params = this.data; + ret = `ALU: 16-bits bitwise XOR (0x${Utils.pad(params.operand1, 16, 4)} ^ 0x${Utils.pad(params.operand2, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.XORB: + params = this.data; + ret = `ALU: 8-bits bitwise XOR (0x${Utils.pad(params.operand1, 16, 2)} ^ 0x${Utils.pad(params.operand2, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.NOT: + params = this.data; + ret = `ALU: 16-bits bitwise NOT (~0x${Utils.pad(params.operand, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.NOTB: + params = this.data; + ret = `ALU: 8-bits bitwise NOT (~0x${Utils.pad(params.operand, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SHL: + params = this.data; + ret = `ALU: 16-bits bitshift left (0x${Utils.pad(params.operand, 16, 4)} << 0x${Utils.pad(params.places, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SHLB: + params = this.data; + ret = `ALU: 8-bits bitshift left (0x${Utils.pad(params.operand, 16, 2)} << 0x${Utils.pad(params.places, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SHR: + params = this.data; + ret = `ALU: 16-bits bitshift right (0x${Utils.pad(params.operand, 16, 4)} >> 0x${Utils.pad(params.places, 16, 4)}) = 0x${Utils.pad(params.result, 16, 4)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + case ALUOperationType.SHRB: + params = this.data; + ret = `ALU: 8-bits bitshift right (0x${Utils.pad(params.operand, 16, 2)} >> 0x${Utils.pad(params.places, 16, 2)}) = 0x${Utils.pad(params.result, 16, 2)}, C = ${params.carryFlag}, Z = ${params.zeroFlag}`; + break; + default: + break; + } + + return ret; + + } + } type PublishALUOperation = (operation: ALUOperation) => void; @@ -389,7 +485,7 @@ export class ArithmeticLogicUnit { this.SR.carry = ret.carryFlag; this.SR.zero = ret.zeroFlag; - this.publishSubstraction(ALUOperationType.ADDB, + this.publishSubstraction(ALUOperationType.SUBB, minuend, subtrahend, ret.result, ret.carryFlag, ret.zeroFlag); return ret.result; diff --git a/src/app/cpu.service.ts b/src/app/cpu.service.ts index 6cb8d79..873a893 100644 --- a/src/app/cpu.service.ts +++ b/src/app/cpu.service.ts @@ -122,7 +122,7 @@ export class ControlUnitOperation implements SystemEvent { break; case ControlUnitOperationType.EXECUTE: params = this.data; - ret = `CU: Execute {0x${Utils.pad(params.opcode, 16, 2)}: ${OpCode[params.opcode]}}` + ret = `CU: Execute instruction {0x${Utils.pad(params.opcode, 16, 2)}: ${OpCode[params.opcode]}}` if (params.operand1Type !== undefined) { @@ -305,6 +305,7 @@ export class CPUService { protected publishALUOperation(operation: ALUOperation) { this.aluOperationSource.next(operation); + this.eventsLogService.log(operation); } diff --git a/src/app/events-log-viewer/events-log-viewer.component.html b/src/app/events-log-viewer/events-log-viewer.component.html index 44b5223..2842b19 100644 --- a/src/app/events-log-viewer/events-log-viewer.component.html +++ b/src/app/events-log-viewer/events-log-viewer.component.html @@ -7,7 +7,7 @@
Events log
- {{i.text}} + {{i.text}}
Control Unit: diff --git a/src/app/events-log-viewer/events-log-viewer.component.ts b/src/app/events-log-viewer/events-log-viewer.component.ts index 6a8e06f..62a5cbe 100644 --- a/src/app/events-log-viewer/events-log-viewer.component.ts +++ b/src/app/events-log-viewer/events-log-viewer.component.ts @@ -2,9 +2,11 @@ import { AfterViewInit, Component, Input, ViewChild, ViewChildren, ElementRef, QueryList } from '@angular/core'; + import { EventsLogService, LoggedEvent } from '../events-log.service'; import { MemoryOperation, MemoryOperationType } from '../memory.service'; import { ControlUnitOperation } from '../cpu.service'; +import { ALUOperation } from '../alu'; class LogLine { @@ -87,6 +89,12 @@ export class EventsLogViewerComponent implements AfterViewInit { `control-unit-event`); this.logLines.push(newLine); + } else if (loggedEvent.systemEvent instanceof ALUOperation && this.enableALU === true) { + + const newLine = new LogLine(`${loggedEvent.time}: ${loggedEvent.systemEvent.toString()}`, + `alu-event`); + this.logLines.push(newLine); + } } diff --git a/src/app/memory-view/memory-view.component.ts b/src/app/memory-view/memory-view.component.ts index cf9c3c5..e46c2c7 100644 --- a/src/app/memory-view/memory-view.component.ts +++ b/src/app/memory-view/memory-view.component.ts @@ -63,6 +63,20 @@ class MemoryCellView { } +class CPURegisterPointer { + + public index: CPURegisterIndex; + public value: number; + + constructor(index: CPURegisterIndex, initialValue: number) { + + this.index = index; + this.value = initialValue; + + } + +} + @Component({ selector: 'app-memory-view', @@ -100,13 +114,7 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { private sspCells: Array = []; private uspCells: Array = []; - private registerAPointer: number; - private registerBPointer: number; - private registerCPointer: number; - private registerDPointer: number; - private registerIPPointer: number; - private registerSSPPointer: number; - private registerUSPPointer: number; + private registerPointers: Map = new Map(); private registerSR: number; @@ -128,18 +136,40 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { const registerBank = this.cpuService.getRegistersBank(); - this.registerAPointer = registerBank.get(CPURegisterIndex.A).value; - this.registerBPointer = registerBank.get(CPURegisterIndex.B).value; - this.registerCPointer = registerBank.get(CPURegisterIndex.C).value; - this.registerDPointer = registerBank.get(CPURegisterIndex.D).value; - this.registerSSPPointer = registerBank.get(CPURegisterIndex.SSP).value; - this.registerUSPPointer = registerBank.get(CPURegisterIndex.USP).value; - this.registerIPPointer = registerBank.get(CPURegisterIndex.IP).value; + const registerAPointer = new CPURegisterPointer(CPURegisterIndex.A, registerBank.get(CPURegisterIndex.A).value); + this.registerPointers.set(CPURegisterIndex.A, registerAPointer); + this.registerPointers.set(CPURegisterIndex.AH, registerAPointer); + this.registerPointers.set(CPURegisterIndex.AL, registerAPointer); + + const registerBPointer = new CPURegisterPointer(CPURegisterIndex.B, registerBank.get(CPURegisterIndex.B).value); + this.registerPointers.set(CPURegisterIndex.B, registerBPointer); + this.registerPointers.set(CPURegisterIndex.BH, registerBPointer); + this.registerPointers.set(CPURegisterIndex.BL, registerBPointer); + + const registerCPointer = new CPURegisterPointer(CPURegisterIndex.C, registerBank.get(CPURegisterIndex.C).value); + this.registerPointers.set(CPURegisterIndex.C, registerCPointer); + this.registerPointers.set(CPURegisterIndex.CH, registerCPointer); + this.registerPointers.set(CPURegisterIndex.CL, registerCPointer); + + const registerDPointer = new CPURegisterPointer(CPURegisterIndex.D, registerBank.get(CPURegisterIndex.D).value); + this.registerPointers.set(CPURegisterIndex.D, registerDPointer); + this.registerPointers.set(CPURegisterIndex.DH, registerDPointer); + this.registerPointers.set(CPURegisterIndex.DL, registerDPointer); + + const registerSSPPointer = new CPURegisterPointer(CPURegisterIndex.SSP, registerBank.get(CPURegisterIndex.SSP).value); + this.registerPointers.set(CPURegisterIndex.SSP, registerSSPPointer); + + const registerUSPPointer = new CPURegisterPointer(CPURegisterIndex.USP, registerBank.get(CPURegisterIndex.USP).value); + this.registerPointers.set(CPURegisterIndex.USP, registerUSPPointer); + + const registerIPPointer = new CPURegisterPointer(CPURegisterIndex.IP, registerBank.get(CPURegisterIndex.IP).value); + this.registerPointers.set(CPURegisterIndex.IP, registerIPPointer); + this.registerSR = registerBank.get(CPURegisterIndex.SR).value; - this.updateCellStyle(this.registerIPPointer); - this.updateCellStyle(this.registerSSPPointer); - this.updateCellStyle(this.registerUSPPointer); + this.updateCellStyle(registerIPPointer.value); + this.updateCellStyle(registerSSPPointer.value); + this.updateCellStyle(registerUSPPointer.value); this.memoryOperationSubscription = this.memoryService.memoryOperation$.subscribe( (memoryOperation) => this.processMemoryOperation(memoryOperation) @@ -239,160 +269,129 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { private operationPush(index: CPURegisterIndex, value: number) { - let previousRegisterSPPointer; + let cells; + + const registerPointer = this.registerPointers.get(index); + const previousRegisterPointer = registerPointer.value; + + registerPointer.value = value; switch (index) { case CPURegisterIndex.SSP: - previousRegisterSPPointer = this.registerSSPPointer; - this.registerSSPPointer = value; - for (let i = 0; previousRegisterSPPointer - i !== this.registerSSPPointer; i++) { - this.sspCells.push(previousRegisterSPPointer - i); - this.updateCellStyle(previousRegisterSPPointer - i); - } + cells = this.sspCells; break; case CPURegisterIndex.USP: - previousRegisterSPPointer = this.registerUSPPointer; - this.registerUSPPointer = value; - for (let i = 0; previousRegisterSPPointer - i !== this.registerUSPPointer; i++) { - this.uspCells.push(previousRegisterSPPointer - i); - this.updateCellStyle(previousRegisterSPPointer - i); - } + cells = this.uspCells; break; } + for (let i = 0; previousRegisterPointer - i !== value; i++) { + cells.push(previousRegisterPointer - i); + this.updateCellStyle(previousRegisterPointer - i); + } + this.updateCellStyle(value); } private operationPop(index: CPURegisterIndex, value: number) { - let previousRegisterSPPointer; + let cells; + + const registerPointer = this.registerPointers.get(index); + const previousRegisterPointer = registerPointer.value; + + registerPointer.value = value; switch (index) { case CPURegisterIndex.SSP: - previousRegisterSPPointer = this.registerSSPPointer; - this.registerSSPPointer = value; - for (let i = 1; previousRegisterSPPointer + i <= this.registerSSPPointer; i++) { - this.sspCells.splice(this.sspCells.indexOf(previousRegisterSPPointer + i), 1); - this.updateCellStyle(previousRegisterSPPointer + i); - } + cells = this.sspCells; break; case CPURegisterIndex.USP: - previousRegisterSPPointer = this.registerUSPPointer; - this.registerUSPPointer = value; - for (let i = 1; previousRegisterSPPointer + i <= this.registerSSPPointer; i++) { - this.uspCells.splice(this.uspCells.indexOf(previousRegisterSPPointer + i), 1); - this.updateCellStyle(previousRegisterSPPointer + i); - } + cells = this.uspCells; break; } - this.updateCellStyle(previousRegisterSPPointer); + for (let i = 1; previousRegisterPointer + i <= value; i++) { + cells.splice(cells.indexOf(previousRegisterPointer + i), 1); + this.updateCellStyle(previousRegisterPointer + i); + } + + this.updateCellStyle(previousRegisterPointer); } private operationWriteRegister(index: CPURegisterIndex, value: number) { - switch (index) { - - case CPURegisterIndex.A: + let display; - const previousRegisterAPointer = this.registerAPointer; - this.registerAPointer = value; + if (index === CPURegisterIndex.SR) { + this.registerSR = value; + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.SSP).value); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.USP).value); + return; + } + + const registerPointer = this.registerPointers.get(index); - if (this.displayA === true) { + const previousRegisterPointer = registerPointer.value; - if (previousRegisterAPointer >= 0 && previousRegisterAPointer < this.size) { - this.updateCellStyle(previousRegisterAPointer); - } - this.updateCellStyle(this.registerAPointer); - } + switch (index) { + case CPURegisterIndex.AH: + case CPURegisterIndex.BH: + case CPURegisterIndex.CH: + case CPURegisterIndex.DH: + registerPointer.value = (previousRegisterPointer & 0x00FF) + (value << 8); break; - case CPURegisterIndex.B: - - const previousRegisterBPointer = this.registerBPointer; - this.registerBPointer = value; - - if (this.displayB === true) { - - if (previousRegisterBPointer >= 0 && previousRegisterBPointer < this.size) { - this.updateCellStyle(previousRegisterBPointer); - } - this.updateCellStyle(this.registerBPointer); - } + case CPURegisterIndex.AL: + case CPURegisterIndex.BL: + case CPURegisterIndex.CL: + case CPURegisterIndex.DL: + registerPointer.value = (previousRegisterPointer & 0xFF00) + value; break; - case CPURegisterIndex.C: - - const previousregisterCPointer = this.registerCPointer; - this.registerCPointer = value; - - if (this.displayC === true) { - - if (previousregisterCPointer >= 0 && previousregisterCPointer < this.size) { - this.updateCellStyle(previousregisterCPointer); - } - this.updateCellStyle(this.registerCPointer); - - } + default: + registerPointer.value = value; break; - case CPURegisterIndex.D: - - const previousregisterDPointer = this.registerDPointer; - this.registerDPointer = value; - - if (this.displayD === true) { + } - if (previousregisterDPointer >= 0 && previousregisterDPointer < this.size) { - this.updateCellStyle(previousregisterDPointer); - } - this.updateCellStyle(this.registerDPointer); + switch (index) { - } + case CPURegisterIndex.A: + case CPURegisterIndex.AH: + case CPURegisterIndex.AL: + display = this.displayA; break; - case CPURegisterIndex.IP: - - const previousregisterIPPointer = this.registerIPPointer; - this.registerIPPointer = value; - - this.updateCellStyle(previousregisterIPPointer); - this.updateCellStyle(this.registerIPPointer); - + case CPURegisterIndex.B: + case CPURegisterIndex.BH: + case CPURegisterIndex.BL: + display = this.displayB; break; - - case CPURegisterIndex.SR: - - this.registerSR = value; - - this.updateCellStyle(this.registerSSPPointer); - this.updateCellStyle(this.registerUSPPointer); - - + case CPURegisterIndex.C: + case CPURegisterIndex.CH: + case CPURegisterIndex.CL: + display = this.displayC; break; - - case CPURegisterIndex.SSP: - - let previousRegisterSPPointer = this.registerSSPPointer; - this.registerSSPPointer = value; - - this.updateCellStyle(previousRegisterSPPointer); - this.updateCellStyle(this.registerSSPPointer); - + case CPURegisterIndex.D: + case CPURegisterIndex.DH: + case CPURegisterIndex.DL: + display = this.displayD; + break; + default: + display = true; break; - case CPURegisterIndex.USP: - - previousRegisterSPPointer = this.registerUSPPointer; - this.registerUSPPointer = value; - - this.updateCellStyle(previousRegisterSPPointer); - this.updateCellStyle(this.registerUSPPointer); + } - break; + if (display === true) { + if (previousRegisterPointer >= 0 && previousRegisterPointer < this.size) { + this.updateCellStyle(previousRegisterPointer); + } + this.updateCellStyle(registerPointer.value); } } @@ -407,8 +406,8 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { this.registerSR |= (1 << bitNumber); } - this.updateCellStyle(this.registerSSPPointer); - this.updateCellStyle(this.registerUSPPointer); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.SSP).value); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.USP).value); } @@ -545,34 +544,34 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { } if (this.displayD === true && - this.registerDPointer === address) { + this.registerPointers.get(CPURegisterIndex.D).value === address) { this.memoryCellViews[address].style = 'marker marker-d'; } if (this.displayC === true && - this.registerCPointer === address) { + this.registerPointers.get(CPURegisterIndex.C).value === address) { this.memoryCellViews[address].style = 'marker marker-c'; } if (this.displayB === true && - this.registerBPointer === address) { + this.registerPointers.get(CPURegisterIndex.B).value === address) { this.memoryCellViews[address].style = 'marker marker-b'; } if (this.displayA === true && - this.registerAPointer === address) { + this.registerPointers.get(CPURegisterIndex.A).value === address) { this.memoryCellViews[address].style = 'marker marker-a'; } - if (this.registerUSPPointer === address && !this.isSupervisorMode()) { + if (this.registerPointers.get(CPURegisterIndex.USP).value === address && !this.isSupervisorMode()) { this.memoryCellViews[address].style = 'marker marker-usp'; } - if (this.registerSSPPointer === address && this.isSupervisorMode()) { + if (this.registerPointers.get(CPURegisterIndex.SSP).value === address && this.isSupervisorMode()) { this.memoryCellViews[address].style = 'marker marker-ssp'; } - if (this.registerIPPointer === address) { + if (this.registerPointers.get(CPURegisterIndex.IP).value === address) { this.memoryCellViews[address].style = 'marker marker-ip'; } @@ -609,22 +608,22 @@ export class MemoryViewComponent implements OnInit, OnDestroy, OnChanges { } if ('displayA' in changes) { - this.updateCellStyle(this.registerAPointer); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.A).value); } if ('displayB' in changes) { - this.updateCellStyle(this.registerBPointer); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.B).value); } if ('displayC' in changes) { - this.updateCellStyle(this.registerCPointer); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.C).value); } if ('displayD' in changes) { - this.updateCellStyle(this.registerDPointer); + this.updateCellStyle(this.registerPointers.get(CPURegisterIndex.D).value); } diff --git a/src/styles.css b/src/styles.css index 028b3f5..f2636a4 100644 --- a/src/styles.css +++ b/src/styles.css @@ -298,7 +298,8 @@ body { } .events-log-list { - overflow-y: scroll; + overflow: auto; + white-space: nowrap; height: 262px; border-radius: 4px; border: 1px solid #ccc;