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

Execution_Alpha_Pause

val Execution_Alpha_Pause: Int = 7

Calculator debugging a program.

Execution_Clear

val Execution_Clear: Int = 6

Execution Mode.

Execution_Error

val Execution_Error: String = "Wrong execution mode!"

Error Message displayed on using the wrong execution mode!

Execution_Halt

val Execution_Halt: Int = 2

Calculator debugging a program.

Execution_Interactive

val Execution_Interactive: Int = 0

Calculator is used interactively.

Execution_Mode

private open var Execution_Mode: Int

Current Execution mode.

Execution_One_Step

val Execution_One_Step: Int = 4

Do a single step and return to Execution_Halt.

Execution_Pause

val Execution_Pause: Int = 3

final Calculator debugging a program.

Execution_Running

val Execution_Running: Int = 1

Calculator running a program.

Execution_Write

val Execution_Write: Int = 5

Execution Mode.

FA2

open var FA2: Tape

A simulated cassette Printer

Form

open var Form: ICalculatorCanvas

Canvas class where we display our result or get our keycodes

FP10

open var FP10: Printer

A simulated Printer Printer

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.

Indicator_Alpha

val Indicator_Alpha: Int = 10

Keyboard Mode Alpha:

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Count

val Indicator_Count: Int = 11

Indicator count:

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode 2, write programms
Pcl: Mode 3, clear, save, load programs.
Deg: Mode 4, Tr
Rad: Mode 5
Gra: Mode 6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Deg

val Indicator_Deg: Int = 7

Trigonometric functions in degrees (360° based)

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Gra

val Indicator_Gra: Int = 9

Trigonometric functions in gradians (400 based)

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Hlt

val Indicator_Hlt: Int = 3

Program halt wait for user response

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Hyp

val Indicator_Hyp: Int = 1

Hyperbolic function active.

Indicator_Inv

val Indicator_Inv: Int = 0

Inverse functions active.

Indicator_K

val Indicator_K: Int = 2

Arithmetic with constants.

Indicator_Pcl

val Indicator_Pcl: Int = 6

Clear program and memory.

Indicator_Rad

val Indicator_Rad: Int = 8

Trigonometric functions in radians (2π based)

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicator_Run

val Indicator_Run: Int = 4

Run and calculation mode.

Indicator_Wrt

val Indicator_Wrt: Int = 5

Write Programs

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indicators

private val Indicators: Array<Boolean>

Indicators:

Inv: Keyboard in inverse move
Hyp: Keyboard in hyperbolic mode - also used for password entry
K: Constant calculation mode
Hlt: halted programm - also used for debugger
Run: Mode1, interactive or program run mode
Wrt: Mode2, write programms
Pcl: Mode3, clear, save, load programs.
Deg: Mode4, Tr
Rad: Mode5
Gra: Mode6
Keyboard_Alpha: Alpha entry and display mofe

Indirect

private open var Indirect: Boolean

Currently indirect addressing is active

Internal_Steps_High

val Internal_Steps_High: Int = 1022

The memory from 1000 ..

Internal_Steps_Low

val Internal_Steps_Low: Int = 1000

The memory from 1000 ..

IO_Count

private open var IO_Count: Int

Number of virtual CPU cycles until next IO run.

IO_Speed

private val IO_Speed: Int = 50

defines how many steps are executed before the display is updated.

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.

Keyboard_Alpha

val Keyboard_Alpha: Int = 2

Keyboard is in alpha mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha mode

Keyboard_Error

val Keyboard_Error: String = "Wrong keyboard mode!"

Error Message displayed on using the wrong keyboard mode!

Keyboard_Hyp

val Keyboard_Hyp: Int = 4

Keyboard is in hyperbolic mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha mode

Keyboard_Inv

val Keyboard_Inv: Int = 1

Keyboard is in inverse mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha mode

Keyboard_Inv_Alpha

val Keyboard_Inv_Alpha: Int = 3

Keyboard is in inverse alpha mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha mode

Keyboard_Inv_Hyp

val Keyboard_Inv_Hyp: Int = 5

Keyboard is in inverse hyperbolic mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha mode

Keyboard_Normal

val Keyboard_Normal: Int = 0

Keyboard is in normal mode

Keyboard_Normal: Keyboard is in normal mode
Keyboard_Inv: Keyboard is in inverse mode
Keyboard_Hyp: Keyboard is in hyperbolic mode
Keyboard_Inv_Hyp: Keyboard is in inverse hyperbolic mode
Keyboard_Alpha: Keyboard is in alpha mode
Keyboard_Inv_Alpha: Keyboard is in inverse alpha 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

L_Used

open var L_Used: Int

Amount of L Register used

L_X

val L_X: Int = 0

L [0] is also the X register.

L_Y

val L_Y: Int = 1

L [1] is also the Y register.

Last_Operation

open var Last_Operation: Int

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

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_n

val M_n: Int = 9

M [9] is also the statistical register n.

M_Sx

val M_Sx: Int = 8

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

M_Sx2

val M_Sx2: Int = 7

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_Return

val Null_Return: Int = 1023

The memory from 1000 ..

Off_Text

private val Off_Text: Array<Short>

Text to display when ( is pressed

Parenthesis_Text

private val Parenthesis_Text: Array<Short>

Text to display when ( is pressed

Pause_Repeat

open var Pause_Repeat: Int

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.

Running_Text

val Running_Text: Array<Short>

Text to display when ( is pressed

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

val Steps: Array<Short>

Calculator Program Memory

Steps_Count

val Steps_Count: Int

Amount of Steps.

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: Memory + 20, Fix instead of RND
2; Memory + 40
3: Memory + 60
4: Memory + 80

User_Steps_High

val User_Steps_High: Int

The memory from 0 ..

User_Steps_Low

val User_Steps_Low: Int

The memory from 0 ..

Functions

fun A(Index: AlphaRegisterType): A_Register

A_Active

open fun A_Active(): AlphaRegisterType

open fun A_Active(A: AlphaRegisterType)

Active A register for row.

Add_Debug_Info

private open fun Add_Debug_Info(Position: Int, Text: Array<Short>)

Add debug info.

Add_Steps

private open fun Add_Steps(Steps: Int, Text: Array<Short>)

Add step count to text field

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.

ARegister_Display_Value_Changed

private open fun ARegister_Display_Value_Changed(event: PropertyChangeEvent)

Clear

open fun Clear(AC: Boolean)

Clean Calculator

clone

protected open fun clone(): Any

Decrement_Program_Store

open fun Decrement_Program_Store()

Decrement where to store the next merged operations.

Display_A

open fun Display_A(Register_Number: AlphaRegisterType)

Display A register

Display_Error

open fun Display_Error(Text: Array<Short>)

Display an error message until C or AC is pressed.

Display_Fatal

open fun Display_Fatal(Text: Array<Short>)

Display an error message until C or AC is pressed.

Display_Program

fun Display_Program()

Display program overview

Display_Program_Overview

open fun Display_Program_Overview()

Display program overview

Display_Steps

open fun Display_Steps()

Display Program Steps

displayClear

open fun displayClear()

Clear all alpha register.

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 text as message

equals

open fun equals(obj: Any): Boolean

Error_Reset

private open fun Error_Reset()

Brings the calculator into a defined state after an error condition.

Execute_Mode_Pcl

private open fun Execute_Mode_Pcl()

Handles the program clear, save and load.

Execute_Mode_Run

open fun Execute_Mode_Run()

Handles running the calculator

Execute_Mode_Wrt

private open fun Execute_Mode_Wrt()

Handles the programm editing

FA2

fun FA2(): Tape

A simulated cassette Printer

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

FP10

fun FP10(): Printer

A simulated cassette Printer

Free_Steps

fun Free_Steps(Text: Array<Short>)

Add total amount of free steps to text;

Get_Alpha_Mode

open fun Get_Alpha_Mode(): Boolean

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

Get_Current_Program

open fun Get_Current_Program(): Short

Get_Program_Text

private open fun Get_Program_Text(For_Debug: Boolean): Array<Short>

Display Program Steps

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

getExecutionMode

open fun getExecutionMode(): Int

Execution mode

getLastStep

open fun getLastStep(): Int

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

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

Handle_IO_HLT

private open fun Handle_IO_HLT(text: Array<Short>): Array<Short>

Handles I/O for HLT and PAUSE mode

Handle_IO_Mode_Pcl

private open fun Handle_IO_Mode_Pcl()

Handles the IO in program-clear mode

Handle_IO_Mode_Wrt

private open fun Handle_IO_Mode_Wrt()

Handles I/O for program-write mode

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()

Clears internal Memory

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()

Sets the opcodes.

Init_Program_Stack

open fun Init_Program_Stack()

init the GSB stack

Init_Steps

open fun Init_Steps()

Clears Program Steps

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_Constant_Mode

fun Is_Constant_Mode(): Boolean

Current mode

Is_Executing_Program

private open fun Is_Executing_Program(): Boolean

checks if we are running a program

Is_HLT_Pause

open fun Is_HLT_Pause(Step_Nr: Int): Boolean

check if Step "Nr" is an Alpha character

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_Shutdown

open 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

open fun Keyboard_Mode(): Int

Get current Keyboard mode

open fun Keyboard_Mode(Keyboard_Mode: Int)

set input mode

fun L(Nr: Int): L_Register

The M-Register are used for general data storage.

load

open fun load(filename: String)

Load the current status of the system

Load_Status

open fun Load_Status()

Load the current status of the system

open fun M(Register: Int): Number

fun M(Register: Int, M: Number)

The M-Register are used for general data storage.

M_Length

open fun M_Length(): Int

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

open fun MF(Register: Int): Number

fun MF(Register: Int, MF: Number)

The M-Register are used for general data storage.

MF_Length

open fun MF_Length(): Int

The M-Register are used for general data storage.

notify

fun notify()

notifyAll

fun notifyAll()

Pop_L

open fun Pop_L()

open fun Pop_L(Operation: Int)

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 .

Program_Counter

open fun Program_Counter(): Int

Get current Program counter.

Program_Position

open fun Program_Position(Program_Token: Short): Short

Return step-postion of given program

Program_Store

open fun Program_Store(): Int

get where to store the next merged operations.

Push_L

private open fun Push_L()

Push stack one down.

open fun Push_L(Operation: Int)

Push value and given operation to stack.

Push_Program_Stack

open fun Push_Program_Stack(Program_Counter: Int)

Program stack used for GSB commands .

Read_Display

open fun Read_Display(Is_X_Register: Boolean)

Read Steps from Simulated Cassette interface.

Read_M

open fun Read_M()

Read M register from file

Read_Steps

open fun Read_Steps()

Read Steps from Simulated Cassette interface.

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.

Resize_M

open fun Resize_M(New_Size: Int)

Set new size for M-register.

Resize_MF

open fun Resize_MF(New_Size: Int)

Set new size for F-register.

run

fun run()

Start Calculator

Save_Status

open fun Save_Status()

Save the current status of the system

Service

open fun Service(Service: IService)

Set Canvas to display result read keyboard

Set_Alpha_Mode

open fun Set_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).

Set_Constant_Mode

fun Set_Constant_Mode(Constant_Mode: Boolean)

Current mode

Set_Current_Program

open fun Set_Current_Program()

Set Current program to program at program counter

open fun Set_Current_Program(Current_Program: Short)

Set_Program_Counter

open fun Set_Program_Counter(Program_Counter: Int)

Set Current Program counter.

Set_Program_Store

open fun Set_Program_Store(Program_Store: Int)

Set where to store the next merged operations.

setDisplayMode

open fun setDisplayMode(displayMode: 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_Formated: Displays the content of the L0 aka X register inside an alpha

setExecutionMode

open fun setExecutionMode(Execution_Mode: Int)

Set new Execution mode

Execution_Interactiv: Calculator is used interactively.
Execution_Running: Calculator running a program.
Execution_Halt: Calculator debugging a program.
Execution_Pause: Calculator pauses for a sec.
Execution_1_Step: Do a single step and return to Execution_Halt.
Execution_Write: Calcluator is in write programm mode.
Execution_Clear: Calcluator is in clear memory mode.
Execution_Alpha_Pause: Initial pause when alpha starts scrolling.
Execution_Alpha_Step: Pause between each character when alpha starts scrolling.