Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formated: Displays the content of the L0 aka X register inside an alpha

Execution_Error

val Execution_Error: String

Error Message displayed on using the wrong execution mode!

Execution_Mode

private open var Execution_Mode: Calculator.Execution_Type

Current Execution mode.

FA6

open var FA6: Tape

A simulated cassette Interface

Form

open var Form: ICalculatorCanvas

Canvas class where we display our result or get our keycodes

FP40

open var FP40: Printer

A simulated Printer Printer

Half_Second

private val Half_Second: Int = 500

Hlt_Position

private open var Hlt_Position: Int

Return Position for HLT Mode.

Ignore_Clear

open var Ignore_Clear: Boolean

The last operation was one of the operations (+-) which disable the clear key.

Indicators

private val Indicators: Array<Boolean>

Indicator_Type.

Indirect

private open var Indirect: Boolean

Currently indirect addressing is active

Internal_Steps_High

private val Internal_Steps_High: Short

The memory from 10000 ..

Internal_Steps_Low

val Internal_Steps_Low: Short

The memory from 10000 ..

IO_Count

private open var IO_Count: Int

Number of virtual CPU cycles until next IO run.

Key_Buffer

private open var Key_Buffer: Int

last key pressed

Key_Flag

private open var Key_Flag: Boolean

a key was pressed

Key_Operations

private open var Key_Operations: Array<Keyboard>

Operations as they come from the keyboard.

Key_Time

private open var Key_Time: Long

System time when last Key was clicked or the last PAUSE started.

Keyboard_Error

private val Keyboard_Error: String

Error Message displayed on using the wrong keyboard mode!

private open var L: Array<L_Register>

The L-Register are used for general calculations.

L_CHANGED

val L_CHANGED: String = "L_Changed"

The L or A register where changed.

L_Count

val L_Count: Int = 12

Amount of L Register

L_Used

open var L_Used: Int

Amount of L Register used

L_X

val L_X: Int

L [0] is also the X register.

L_Y

val L_Y: Int

L [1] is also the Y register.

Last_Comp_Mode

private open var Last_Comp_Mode: Calculator.Indicator_Type

the last comp mode used.

Last_Operation

private open var Last_Operation: L_Register.Operation_Type

Last operation chosen by user - used for the K option.

Logger

private val Logger: Logger

class Logger instance

logger

private val logger: Logger

class logger instance

private open var M: Array<Number>

The M-Register are used for general data storage.

M_CHANGED

val M_CHANGED: String = "M_Changed"

An M or MF register has changed.

M_Count

val M_Count: Int = 100

Amount of M Register

M_n

val M_n: Int

M [9] is also the statistical register n.

M_Sx

val M_Sx: Int

M [8] is also the statistical register Σx.

M_Sx2

val M_Sx2: Int

M [7] is also the statistical register Σx².

Merge_Key

open var Merge_Key: Keyboard

Key Operations which currently merged to a Calculator operation.

Merge_Token

private open var Merge_Token: IProgrammable_Operation

Multi Keystroke Operation like Alpha, Degree, Eng, Save, Load in progress

Merged_Operations

open var Merged_Operations: Array<IProgrammable_Operation>

Operations as they executed by the calculator.

private open var MF: Array<Number>

The MF-Register are used for special data storage.

Null_Program

val Null_Program: Calculator.Program_Type

no program

Null_Return

val Null_Return: Int

The memory from 1000 ..

Null_Steps

private val Null_Steps: Array<Short>

Do not display the steps.

Off_Text

private val Off_Text: Array<Short>

Text to display when ( is pressed

P1x_Info_Character

private val P1x_Info_Character: Int = 14

Parenthesis_Text

private val Parenthesis_Text: Array<Short>

Text to display when ( is pressed

Program_Counter

private open var Program_Counter: Int

Current Program counter .

Program_Stack

open var Program_Stack: Array<Int>

Program stack used for GSB commands .

Program_Stack_Pointer

private open var Program_Stack_Pointer: Int

Program stack poiunter used for GSB commands .

Program_Store

private open var Program_Store: Int

Where to store the next merged operations.

propertyChangeSupport

private val propertyChangeSupport: PropertyChangeSupport

Handle property changes.

Realistic_Speed

val Realistic_Speed: Boolean

Run calculator with realistic speed - just about as fast as the original.

Row_Numeric

val Row_Numeric: Int = 1

Numeric / Lower Row.

Row_Steps

val Row_Steps: Int = 2

The 4 Steps charactersConvenience and performance constants — so we don't have to go though the enum for constant access<

Row_Text

val Row_Text: Int = 0

Text / Upper RowConvenience and performance constants — so we don't have to go though the enum for constant access<

RS232

open var RS232: Serial

A simulated serial Interface

Serial

private open var Serial: Serial

A simulated RS232

Service

private open var Service: IService

Canvas class where we display our result or get our keycodes

Stack_Count

val Stack_Count: Int = 20

deeps of the program stack.

STATUS_CHANGED

val STATUS_CHANGED: String = "Status_Changed"

Program or program counter where changes where changed.

STEP_CHANGED

val STEP_CHANGED: String = "Step_Changed"

Program or program counter where changes where changed.

Steps

private val Steps: Array<Short>

Calculator Program Memory

Steps_Between_IO

private val Steps_Between_IO: Int = 35

Steps_Count

val Steps_Count: Int

Amount of Steps.

Steps_Text

private open var Steps_Text: Array<Short>

The text to display in the steps field.

TAG

private val TAG: String

class Logger tag.

private val TAG: String

class logger tag.

Token_Plane

private open var Token_Plane: Calculator.Token_Plane_Type

Active plane:

0: Keyboard_Normal
1: $2B: Memory + 20, Fix instead of RND
2: $2C: Memory + 40
3: $2D: Memory + 60
4: $2F: Memory + 80
5: $EA: P1_
6: $EB: ExFn Plane

User_Steps_High

val User_Steps_High: Short

The memory from 0 ..

User_Steps_Low

val User_Steps_Low: Short

The memory from 0 ..

Functions

fun A(Register: AlphaRegisterType): A_Register

The A Register contains the Keyboard_Alpha data of the display.

A_Active

open fun A_Active(Row: Calculator.Row_Type): AlphaRegisterType

open fun A_Active(Row: Calculator.Row_Type, A: AlphaRegisterType)

Active A register for row.

addPropertyChangeListener

open fun addPropertyChangeListener(listener: PropertyChangeListener)

Add a PropertyChangeListener to the listener list.

open fun addPropertyChangeListener(propertyName: String, listener: PropertyChangeListener)

Add a PropertyChangeListener for a specific property.

Alpha_Mode

open fun Alpha_Mode(Alpha_Mode: Boolean)

Checks if the calculator is in Alpha mode by checking merged operation (when execution programms the alpha indicator is not set).

BaseN

open fun BaseN(Mode: Calculator.Indicator_Type)

activate or deactivate base n mode.

Clear

open fun Clear(AC: Boolean)

Clean Calculator

clone

protected open fun clone(): Any

Constant_Mode

fun Constant_Mode(): Boolean

fun Constant_Mode(Constant_Mode: Boolean)

Current mode

Current_Program

open fun Current_Program(): Calculator.Program_Type

open fun Current_Program(Current_Program: Calculator.Program_Type)

Decrement_Program_Store

open fun Decrement_Program_Store()

Decrement where to store the next merged operations.

Display_A

open fun Display_A(Row: Calculator.Row_Type, Register: AlphaRegisterType)

Display A register in given row

Display_Program_Overview

open fun Display_Program_Overview()

Display program overview

displayClear

open fun displayClear()

Clear all alpha register.

displayException

open fun displayException(exception: Throwable)

display additional information on the error.

displayFormatted

open fun displayFormatted(text: Array<Short>)

Display value as formatted text

displayKey

open fun displayKey(text: Array<Short>)

* Display Key merge info.

displayL

open fun displayL()

Reset current value Display

displayMessage

open fun displayMessage(text: Array<Short>)

Display texts as dual line message

Enable_BaseN

open fun Enable_BaseN()

enable Bin Mode

equals

open fun equals(obj: Any): Boolean

Execute_Key

open fun Execute_Key(Opcode: Short)

Execute keyboard ob code

Execute_Mode_Run

protected open fun Execute_Mode_Run()

Handles running the calculator

FA6

fun FA6(): Tape

A simulated cassette Interface

finalize

protected open fun finalize()

forceIO

open fun forceIO(resetKeyTime: Boolean)

Force IO Handling next round.

Form

open fun Form(Form: ICalculatorCanvas)

Set Canvas to display result read keyboard

FP40

fun FP40(): Printer

A simulated cassette Printer

Free_Steps

fun Free_Steps()

Add total amount of free steps to text;

Get_A

open fun Get_A(Nr: AlphaRegisterType): String

Get_Display

open fun Get_Display(): String

Get content of Calculator Display

Get_F

open fun Get_F(Nr: Int): String

Get_L

open fun Get_L(Nr: Int): String

Get_M

open fun Get_M(Nr: Int): String

Get_Memory

open fun Get_Memory(): String

Get_P

open fun Get_P(Nr: AlphaRegisterType): String

Get_Registers

open fun Get_Registers(): String

Get text for clipboard

Get_Stack

open fun Get_Stack(Nr: Int): String

Returns the memory step x as debug info or null for step 0xff which is the empty step.

Get_Steps_Text

open fun Get_Steps_Text(): Array<Short>

steps text

getClass

fun getClass(): Class<out Any>

getDisplayMode

open fun getDisplayMode(): DisplayType

Current display mode

Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formatted: Displays the content of the L0 aka X register inside an alpha

open fun getDisplayMode(Row: Calculator.Row_Type): DisplayType

Current display mode

Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formmated: Displays the content of the L0 aka X register inside an alpha

getExecutionMode

open fun getExecutionMode(): Calculator.Execution_Type

Execution mode

getLastStep

open fun getLastStep(): Int

locate the last step to display the free steps or for debugging.

getPauseTime

open fun getPauseTime(): Long

The manual says that a PAUSE takes about a second.

getPauseWait

open fun getPauseWait(): Long

Intermediate wait in milliseconds while pause is executed

getRealisticSpeedWait

open fun getRealisticSpeedWait(): Long

additional wait to make simulator more realistic.

getStackPointer

open fun getStackPointer(): Int

return current stack pointer

Half_Circle

fun Half_Circle(): Number

fun Half_Circle(Half_Circle: Number)

convert an angle to Deg/Rad/Grad

Handle_IO

open fun Handle_IO()

Display result and read keyboard

hashCode

open fun hashCode(): Int

Hlt_Position

open fun Hlt_Position(): Int

open fun Hlt_Position(Hlt_Position: Int)

Return Position for HLT Mode.

Increment_Hlt_Position

open fun Increment_Hlt_Position()

Increment Current Program counter.

Increment_Program_Counter

open fun Increment_Program_Counter()

Increment Current Program counter.

Increment_Program_Store

open fun Increment_Program_Store()

Increment where to store the next merged operations.

Init_A

open fun Init_A()

Clears A-register

Init_Keycodes

open fun Init_Keycodes()

Setup the keyboard

Init_L

open fun Init_L()

Clears L-register

Init_M

open fun Init_M()

Clears M-register.

Init_MF

open fun Init_MF()

Clears MF-register.

Init_Opcodes

open fun Init_Opcodes()

Clears internal Memory

Init_Steps

open fun Init_Steps()

Clears Programm Steps

Is_2nd_Mode

open fun Is_2nd_Mode(): Boolean

2ndF Mode?

Is_Alpha

open fun Is_Alpha(Step_Nr: Int): Boolean

check if Step "Nr" is an Alpha character

Is_Alpha_Mode

open fun Is_Alpha_Mode(): Boolean

Alpha Mode?

Is_BaseN

open fun Is_BaseN(): Boolean

Bin Mode?

Is_BaseN_B

open fun Is_BaseN_B(): Boolean

Bin Mode?

Is_BaseN_D

open fun Is_BaseN_D(): Boolean

Decimal Mode?

Is_BaseN_H

open fun Is_BaseN_H(): Boolean

Hex Mode?

Is_BaseN_O

open fun Is_BaseN_O(): Boolean

Oct Mode?

Is_End_Program

fun Is_End_Program(Position: Int): Boolean

check for end of program

Is_Mode

open fun Is_Mode(): Boolean

check if mode switch is active

Is_Program_Stack_Empty

open fun Is_Program_Stack_Empty(): Boolean

Program stack used for GSB commands .

Is_Program_Stack_Full

open fun Is_Program_Stack_Full(): Boolean

Program stack used for GSB commands .

Is_Shift_Mode

open fun Is_Shift_Mode(): Boolean

Shift Mode?

Is_Shutdown

fun Is_Shutdown(): Boolean

Calculator is not running - needed for end program.

isIndirect

open fun isIndirect(): Boolean

isRunning

open fun isRunning(): Boolean

Calculator is running - needed for power saving.

isWaiting

open fun isWaiting(): Boolean

is waiting in interactive mode for user input.

Keyboard_Mode

fun Keyboard_Mode(): Calculator.Keyboard_Mode

Get current Keyboard mode

open fun Keyboard_Mode(Keyboard_Mode: Calculator.Keyboard_Mode)

set input mode

fun L(Register: Int): L_Register

Last_Comp_Mode

open fun Last_Comp_Mode(): Calculator.Indicator_Type

the last comp mode used.

Last_Operation

open fun Last_Operation(): L_Register.Operation_Type

open fun Last_Operation(Last_Operation: L_Register.Operation_Type)

load

open fun load(filename: String)

Load the current status of the system

open fun load()

Load the current status of the system from default filename

fun M(Register: Int): Number

fun M(Register: Int, M: Number)

The M-Register are used for general data storage.

Merge_Key

open fun Merge_Key(): Keyboard

open fun Merge_Key(Merge_Key: Keyboard)

Key Operations which currently merged to a Calculator operation.

Merge_Token

open fun Merge_Token(): IProgrammable_Operation

open fun Merge_Token(Merge_Token: IProgrammable_Operation)

Multi Keystroke Operation like Alpha, Degree, Eng, Save, Load in progress

Merged_Operations

fun Merged_Operations(Opcode: Int): IProgrammable_Operation

Operations as they executed by the calculator.

fun MF(Register: Int): Number

fun MF(Register: Int, MF: Number)

The MF-Register are used for special data storage.

notify

fun notify()

notifyAll

fun notifyAll()

Pop_L

open fun Pop_L()

open fun Pop_L(Operation: L_Register.Operation_Type)

Pop values from stack by triggering an calculation run up the the level Operation

Pop_Program_Stack

open fun Pop_Program_Stack(): Int

Program stack used for GSB commands .

Previous_Step

open fun Previous_Step(Step_Nr: Int): Short

get the previous step to a given step number or 255 when there is none.

Program_Counter

open fun Program_Counter(): Int

Get current Program counter.

open fun Program_Counter(Program_Counter: Int)

Set Current Program counter.

Program_Position

open fun Program_Position(Program: Calculator.Program_Type): Short

Return step-position of given program

Program_Store

open fun Program_Store(): Int

get where to store the next merged operations.

open fun Program_Store(Program_Store: Int)

Set where to store the next merged operations.

Push_L

open fun Push_L(Operation: L_Register.Operation_Type)

Push value and given operation to stack.

Push_Program_Stack

open fun Push_Program_Stack(Program_Counter: Int)

Program stack used for GSB commands .

removePropertyChangeListener

open fun removePropertyChangeListener(listener: PropertyChangeListener)

Remove a PropertyChangeListener from the listener list.

open fun removePropertyChangeListener(propertyName: String, listener: PropertyChangeListener)

Remove a PropertyChangeListener for a specific property.

reset

open fun reset()

Total Reset calculator.

RS232

fun RS232(): Serial

A simulated cassette Interface

run

fun run()

Start Calculator

save

open fun save()

Load the current status of the system

open fun save(filename: String)

Save Calculator state

Save_Status

open fun Save_Status()

Save the current status of the system

SecondF

open fun SecondF(): Boolean

check if 2ndF mode is active

Service

open fun Service(Service: IService)

Set Canvas to display result read keyboard

Set_Current_Program

open fun Set_Current_Program()

Set Current program to programm at program counter

Set_Keyboard_No_Shift

open fun Set_Keyboard_No_Shift()

reset shift indicators

Set_Mode

open fun Set_Mode(activate: Boolean)

activate or deactivate mode switch

setDisplayMode

open fun setDisplayMode(displayMode: DisplayType)

open fun setDisplayMode(Row: Calculator.Row_Type, Display_Mode: DisplayType)

Current display mode

Display_Alpha: Displays the content of the Alpha register.
Display_L: Displays the content of the L0 aka X register.
Display_Formatted: Displays the content of the L0 aka X register inside an alpha