When you press digits on the HP-29C, you go into “Input Mode”. What is that, and how does it work?
The input_mode process is quite lengthy as you need to see what happens before and after pressing the decimal point “dot” key, and you also need a few digits on each side to see how it deals with tens as well as ones, and hundredths as well as tenths.
Short Summary
The short version is: it saves the display formatted value in ram[30] and also adds two settings in there. The sign digit gets set to 1 if the decimal point has already been pressed. ram[30][0] is the exponent for the current value.
It is clever to save the display formatted value and decimal point settings. That IS the current state during input mode and it is easy to add digits and update the display accordingly. But, boy oh boy, it isn’t simple to follow.
You won’t believe it but, the following is what started as the summary of how input mode works.
First Digit
When you press the first digit, it sets input_mode by setting s12.
It also shuffles the digit to the left of the display and updates ram[30] and ram[47].
The sequence looks like:
00173: if 0 = s 15 then goto 00152 ; 4 pressed s15=1
00175: display off ;
00176: ...
00222: a -> rom address ; A=0000FFFFFFF340
key_4:
00464: ... ; C=00000000000004
digit:
00745: c + 1 -> c[p] ; C=00000000000014 (hex code)
00746: ... ;
01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14
00563: ... ; A=00000000000014 M1=00000000000014
01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14
00570: ... ; C=00000000000000 (B->C)
06025: p <- 12 ; P=12
06026: 0 -> s 11 ;
06027: a -> rom address ;
hex_1x: ; hex codes 10-19 (digit 0-9), and others
06001: ... ;
07014: ... ; check 1x, x is 0-9
07164: ... ;
07400: if 1 = s 12 then goto 01417 ; if not first digit
07402: if 0 = s 9 then goto 01405 ; if auto_enter
07404: c -> stack ; push existing X up the stack
07405: 1 -> s 9 ; endif (and set auto_enter for nxt)
07406: 0 -> c[w] ; X=0
07407: binary ;
07410: c - 1 -> c[w] ; C=FFFFFFFFFFFFFF
07411: 0 -> c[s] ; C=0FFFFFFFFFFFFF
07412: f exch a ; A=00000000000010
07413: 0 -> a[x] ; A=00000000000000
07414: f exch a ; A=00000000000004
07415: 1 -> s 12 ; S=...3.5...9..C..F input_mode
07416: if n/c goto 0022 ;
;
; shift digit from A[0] to correct position
07422: p <- 1 ; P= 1
07423: c + 1 -> c[p] ; C=0FFFFFFFFFFF0F
07424: if n/c goto 0051 ;
07425: shift left a[w] ; A=00000000000040
07426: p + 1 -> p ; P= 2
07427: if p # 13 then goto 01423 ;
07423: ... ; C=0FFFFFFFFFF00F A=00000000000400 P= 3
07423: ... ; C=0FFFFFFFFF000F A=00000000004000 P= 4
07423: ... ; C=0FFFFFFFF0000F A=00000000040000 P= 5
07423: ... ; C=0FFFFFFF00000F A=00000000400000 P= 6
07423: ... ; C=0FFFFFF000000F A=00000004000000 P= 7
07423: ... ; C=0FFFFF0000000F A=00000040000000 P= 8
07423: ... ; C=0FFFF00000000F A=00000400000000 P= 9
07423: ... ; C=0FFF000000000F A=00004000000000 P=10
07423: ... ; C=0FF0000000000F A=00040000000000 P=11
07423: ... ; C=0F00000000000F A=00400000000000 P=12
07423: ... ; C=0000000000000F A=04000000000000 P=13
07431: p - 1 -> p ; P=12
07432: a exchange c[wp] ; A=0000000000000F C=04000000000000
07433: p - 1 -> p ; P=11
07434: c -> a[w] ; A=04000000000000
07435: c - 1 -> c[wp] ; C=04FFFFFFFFFFFF (" 4 ")
07436: a exchange c[x] ; A=04000000000FFF C=04FFFFFFFFF000
07437: if a[m] # 0 then goto 01465 ;
07465: jsb 0067 ;
; looks like it adjusts exponent for precision (f) and
; normalizes - don't want C[12] (first digit) =0
07467: a exchange b[x] ; A=04000000000000 B=00000000000FFF
07470: decimal ;
07471: 0 -> a[x] ;
07472: f -> a ;
07473: a + c -> c[x] ;
07474: p <- 12 ; P=12
07475: if c[p] # 0 then goto 01505 ;
07505: a exchange b[x] ; A=04000000000FFF B=00000000000000
07506: binary ;
07507: return ;
07466: if n/c goto 0041 ;
07441: a exchange c[ms] ; A=04FFFFFFFFFFFF C=04000000000000
07442: ... ; C->B, B=04000000000000
07444: jsb 0203 ;
; A[0]=f; A->ram[30]
07603: if 0 = s 4 then goto 01607 ;
07607: f -> a ; A=04FFFFFFFFFFF0
07610: binary ;
07611: if 0 = s 7 then goto 01617 ;
07617: p <- 1 ; P= 1
07620: load constant 1 ; C=04000000000010 P= 0
07621: c -> addr ;
07622: a exchange c[w] ; A=04000000000010 C=04FFFFFFFFFFF0
07623: c -> data register 14 ;
07624: a exchange c[w] ; A=04FFFFFFFFFFF0 C=04000000000010
07625: c -> a[s] ;
07626: return ;
07445: b -> c[w] ; C=04000000000000
07446: jsb 0347 ;
; B->C->ram[47]
07747: p <- 1 ; P= 1
07750: load constant 2 ; C=04000000000020 P= 0
07751: c -> addr ;
07752: b -> c[w] ; C=04000000000000
07753: c -> data register 15 ;
07754: return ;
07447: delayed rom 0 ;
07450: if n/c goto 0063 ;
00063: jsb 0323 ;
; B->C, ram[47]->B
00323: p <- 1 ; P= 1
00324: load constant 2 ; C=04000000000020 P= 0
00325: c -> addr ;
00326: data register -> c 15 ; C=04000000000000
00327: b exchange c[w] ;
00330: return ;
00064: if n/c goto 0114 ;
00114: jsb 0315 ;
00315: if 1 = s 2 then goto 00321 ;
00317: if 0 = s 1 then goto 00322 ;
00322: return ;
00115: ... ;
01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14
00120: b -> c[w] ;
00121: if 1 = s 2 then goto 00223 ;
00123: 0 -> s 1 ;
; A=04FFFFFFFFFFF0 B=04000000000000 C=04000000000000
; M1=00000000000014 S=...3.5...9..C..F f=0
00124: ...
Second Digit
It behaves a little differently if you press another digit key:
00173: if 0 = s 15 then goto 00152 ; 5 pressed (S=...3.5...9..C..F) 00175: display off ; 00176: ... ; B=04000000000000 C=04000000000000 00222: a -> rom address ; A=04FFFFFFFFF330 P= 1 key_5: 00463: ... ; C=04000000000005 digit: 00745: c + 1 -> c[p] ; C=04000000000015 C[1,0]=hex code 00746: ... ; A=04000000000015 M1=04000000000015 06024: b -> c[w] ; C=04000000000000 06025: p <- 12 ; P=12 06026: 0 -> s 11 ; 06027: a -> rom address ; hex_1x: 06001: ... 07014: ... ; check 1x, x is 0-9 07164: ... ; 07400: if 1 = s 12 then goto 01417 ; ; second or later digit (s12 already set) 07417: jsb 0142 ; ; ram[30]->C c[0]<>f 07542: p <- 1 ; P= 1 07543: binary ; 07544: load constant 1 ; C=04000000000010 P= 0 07545: c -> addr ; 07546: data register -> c 14 ; C=04FFFFFFFFFFF0 07547: a exchange c[p] ; A=04000000000010 C=04FFFFFFFFFFF5 07550: f exch a ; (A[0]=0 f=0) 07551: a exchange c[p] ; A=04000000000015 C=04FFFFFFFFFFF0 07552: p <- 13 ; P=13 07553: if c[s] = 0 then goto 01601 ; 07601: binary ; 07602: return ; 07420: if 1 = s 4 then goto 01510 ; ; shift digit from A[0] to correct position 07422: p <- 1 ; P= 1 07423: c + 1 -> c[p] ; C=04FFFFFFFFFF00 07424: if n/c goto 0051 ; 07425: shift left a[w] ; A=40000000000150 07426: p + 1 -> p ; P= 2 07427: if p # 13 then goto 01423 ; 07423: ... ; C=04FFFFFFFFF000 A=00000000001500 P= 3 07423: ... ; C=04FFFFFFFF0000 A=00000000015000 P= 4 07423: ... ; C=04FFFFFFF00000 A=00000000150000 P= 5 07423: ... ; C=04FFFFFF000000 A=00000001500000 P= 6 07423: ... ; C=04FFFFF0000000 A=00000015000000 P= 7 07423: ... ; C=04FFFF00000000 A=00000150000000 P= 8 07423: ... ; C=04FFF000000000 A=00001500000000 P= 9 07423: ... ; C=04FF0000000000 A=00015000000000 P=10 07423: ... ; C=04F00000000000 A=00150000000000 P=11 07423: ... ; C=04000000000000 A=01500000000000 P=12 07423: ... ; C=05000000000000 07424: if n/c goto 0051 ; ; exited loop before P=13 (12) because found non-F value at C[12] 07451: c - 1 -> c[p] ; C=04000000000000, put value back 07452: if p # 3 then goto 01457 ; 07457: if 1 = s 7 then goto 01431 ; ; ; f++ 07461: f exch a ; 07462: a + 1 -> a[x] ; A=01500000000001 07463: f exch a ; A=01500000000000 f=1 07464: if n/c goto 0031 ; ; 07431: p - 1 -> p ; P=11 07432: a exchange c[wp] ; A=01000000000000 C=04500000000000 07433: p - 1 -> p ; P=10 07434: c -> a[w] ; A=04500000000000 07435: c - 1 -> c[wp] ; C=045FFFFFFFFFFF 07436: a exchange c[x] ; A=04500000000FFF C=045FFFFFFFF000 07437: if a[m] # 0 then goto 01465 ; 07465: jsb 0067 ; ; looks like it adjusts exponent for precision (f) and ; normalizes - don't want C[12] (first digit) =0 07467: a exchange b[x] ; A=04500000000000 B=04000000000FFF 07470: decimal ; 07471: 0 -> a[x] ; 07472: f -> a ; A=04500000000001 07473: a + c -> c[x] ; C=045FFFFFFFF001 07474: p <- 12 ; P=12 07475: if c[p] # 0 then goto 01505 ; 07505: a exchange b[x] ; A=04500000000FFF B=04000000000001 07506: binary ; 07507: return ; 07466: if n/c goto 0041 ; 07441: a exchange c[ms] ; A=045FFFFFFFFFFF C=04500000000001 07442: ... ; C->B B=04500000000001 07444: jsb 0203 ; ; A[0]=f; A->ram[30] 07603: if 0 = s 4 then goto 01607 ; 07607: f -> a ; A=045FFFFFFFFFF1 07610: binary ; 07611: if 0 = s 7 then goto 01617 ; 07617: p <- 1 ; P= 1 07620: load constant 1 ; C=04500000000011 P= 0 07621: c -> addr ; 07622: a exchange c[w] ; A=04500000000011 C=045FFFFFFFFFF1 07623: c -> data register 14 ; 07624: a exchange c[w] ; A=045FFFFFFFFFF1 C=04500000000011 07625: c -> a[s] ; 07626: return ; 07445: ... ; B->C C=04500000000001 07747: ... ; B->C->ram[47], P=0 00323: ... ; B->C, ram[47]->B, P=0 00115: ... ; 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 00120: ... ; ; A=045FFFFFFFFFF1 B=04000000000001 C=04500000000001 ; M1=04000000000015 S=...3.5...9..C..F f=1 00124: ... ; M1=04500000000001 ; C=04500000000001 B=20900000000000 A=045FFFFFFFFF00 P=11 00144: cpu woodstock ; 00145: display off ; 00146: display toggle ; 00147: 0 -> s 15 ; S=...3.5...9..C... 00150: if 1 = s 15 then goto 00147 ; 00152: ...
Press Dot
At some point, we press dot to mark the decimal point.
00173: if 0 = s 15 then goto 00152 ; S=...3.5...9..C..F (dot pressed) 00175: display off ; 00176: ... ; B=04500000000001 C=04500000000000 P=1 00222: a -> rom address ; A=045FFFFFFFF2E0 key_dot: 00456: ... ; C=0450000000001A P=1 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 00565: ... ; A=0450000000001A 00566: ... ; C=04500000000001 M1=0450000000001A 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 06021: ... 06025: p <- 12 ; P=12 06026: 0 -> s 11 ; 06027: a -> rom address ; A=0450000000001A hex_1x: 06001: ... ; dot is hex code 1A 07014: ... ; check 1x, x is 0-9 - it's not 07025: ... ; A=450000000001A0 07027: a -> rom address ; func_dot: 07032: ... ; 07627: if 1 = s 12 then goto 01635 ; if input_mode (yes) 07635: jsb 0142 ; ; ram[30]->C, mainly 07542: p <- 1 ; P= 1 07543: binary ; 07544: load constant 1 ; C=04500000000011 P= 0 07545: c -> addr ; 07546: data register -> c 14 ; C=045FFFFFFFFFF1 07547: a exchange c[p] ; A=450000000001A1 C=045FFFFFFFFFF0 07550: f exch a ; (A[0]=1 f=1) 07551: a exchange c[p] ; A=450000000001A0 C=045FFFFFFFFFF1 07552: p <- 13 ; P=13 07553: if c[s] = 0 then goto 01601 ; 07601: binary ; 07602: return ; 07636: 1 -> s 7 ; S=...3.5.7.9..C..F 07637: a exchange c[w] ; A=045FFFFFFFFFF1 C=450000000001A0 07640: b -> c[w] ; C=04500000000001 07641: if 0 = s 4 then goto 01444 ; 07444: jsb 0203 ; ; A[0]=f; A->ram[30] 07603: if 0 = s 4 then goto 01607 ; 07607: f -> a ; 07610: binary ; 07611: if 0 = s 7 then goto 01617 ; 07613: a + 1 -> a[s] ; A=145FFFFFFFFFF1 07614: if 0 = s 4 then goto 01617 ; 07617: p <- 1 ; P= 1 07620: load constant 1 ; C=04500000000011 P= 0 07621: c -> addr ; 07622: a exchange c[w] ; A=04500000000011 C=145FFFFFFFFFF1 07623: c -> data register 14 ; 07624: a exchange c[w] ; A=145FFFFFFFFFF1 C=04500000000011 07625: c -> a[s] ; A=045FFFFFFFFFF1 07626: return ; 07445: b -> c[w] ; C=04500000000001 07446: ... ; B->ram[47] 07447: delayed rom 0 ; 07450: if n/c goto 0063 ; 00063: ... ; ram[47]->B 00064: ... ; 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 00120: ... ; ; A=045FFFFFFFFFF1 B=04500000000001 C=04500000000001 ; S=...3.5...9..C..F f=1 00124: ... ; A=045FFFFFFFFF00 B=20900000000000 C=04500000000001 ; M1=04500000000001 P=11 00144: cpu woodstock ; 00145: display off ; 00146: display toggle ; 00147: 0 -> s 15 ; S=...3.5...9..C... 00150: if 1 = s 15 then goto 00147 ; 00152: ...
Press 6
00173: if 0 = s 15 then goto 00152 ; S=...3.5...9..C..F 00175: display off ; 00176: ... ; B=04500000000001 C=04500000000000 P= 1 00222: a -> rom address ; A=045FFFFFFFF320 (0x32=062) key_6: ; (s13 gets set if digit>5, see prefixes) 00462: ... ; S=...3.5...9..CD.F C=04500000000006 digit: 00745: c + 1 -> c[p] ; C=04500000000016 (hex code) 00746: ... ; 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 01177: ... ; S=...3.5...9..C..F 00563: ... ; A=04500000000016 M1=04500000000016 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 00570: ... ; B->C=04500000000001 06025: p <- 12 ; P=12 06026: 0 -> s 11 ; 06027: a -> rom address ; hex_1x: 06001: ... ; 07014: ... ; check 1x, x is 0-9 07164: ... ; 07400: if 1 = s 12 then goto 01417 ; if not first digit - true, go ; second or later digit (s12 already set) 07417: jsb 0142 ; ram[30]->C, C[0]<>f s7=(dot?)1:0 07542: p <- 1 ; P= 1 07543: binary ; 07544: load constant 1 ; C=04500000000011 P= 0 07545: c -> addr ; 07546: data register -> c 14 ; C=145FFFFFFFFFF1 07547: a exchange c[p] ; A=04500000000011 C=145FFFFFFFFFF6 07550: f exch a ; 07551: a exchange c[p] ; A=04500000000016 C=145FFFFFFFFFF1 07552: p <- 13 ; P=13 07553: if c[s] = 0 then goto 01601 ; 07555: c - 1 -> c[s] ; C=045FFFFFFFFFF1 07556: if c[s] # 0 then goto 01562 ; 07560: 1 -> s 7 ; S=...3.5.7.9..C..F 07561: if n/c goto 0201 ; 07601: binary ; 07602: return ; ; note ram[30][s]==1 so s7 got set 07420: if 1 = s 4 then goto 01510 ; ; shift digit from A[0] to correct position 07422: p <- 1 ; P= 1 07423: c + 1 -> c[p] ; C=045FFFFFFFFF01 07424: if n/c goto 0051 ; 07425: shift left a[w] ; A=45000000000160 07426: p + 1 -> p ; P= 2 07427: if p # 13 then goto 01423 ; 07423: ... ; C=045FFFFFFFF001 A=50000000001600 P= 3 07423: ... ; C=045FFFFFFF0001 A=00000000016000 P= 4 07423: ... ; C=045FFFFFF00001 A=00000000160000 P= 5 07423: ... ; C=045FFFFF000001 A=00000001600000 P= 6 07423: ... ] ; C=045FFFF0000001 A=00000016000000 P= 7 07423: ... ; C=045FFF00000001 A=00000160000000 P= 8 07423: ... ; C=045FF000000001 A=00001600000000 P= 9 07423: ... ; C=045F0000000001 A=00016000000000 P=10 07423: ... ; C=04500000000001 A=00160000000000 P=11 07423: c + 1 -> c[p] ; C=04600000000001 07424: if n/c goto 0051 ; ; exit loop 07451: c - 1 -> c[p] ; C=04500000000001, put value back 07452: if p # 3 then goto 01457 ; 07457: if 1 = s 7 then goto 01431 ; if dot_pressed (yes, go) ; ; NOTE: skipping bit that incremented f with each digit ; 07431: p - 1 -> p ; P=10 07432: a exchange c[wp] ; A=00100000000001 C=04560000000000 07433: p - 1 -> p ; P= 9 07434: c -> a[w] ; A=04560000000000 07435: c - 1 -> c[wp] ; C=0456FFFFFFFFFF 07436: a exchange c[x] ; A=04560000000FFF C=0456FFFFFFF000 07437: if a[m] # 0 then goto 01465 ; 07465: jsb 0067 ; ; looks like it adjusts exponent for precision (f) and ; normalizes - don't want C[12] (first digit) =0 07467: a exchange b[x] ; A=04560000000001 B=04500000000FFF ; b[x] is the exponent we had last time, 001, for 045... = 4.5e1 = "45." 07470: decimal ; 07471: 0 -> a[x] ; A=04560000000000 07472: f -> a ; A=04560000000001 (f is still 1) 07473: a + c -> c[x] ; C=0456FFFFFFF001 "45.6 blanks" 07474: p <- 12 ; P=12 07475: if c[p] # 0 then goto 01505 ; mantissa in range 1-9, ok 07505: a exchange b[x] ; A=04560000000FFF B=04500000000001 07506: binary ; 07507: return ; 07466: if n/c goto 0041 ; 07441: a exchange c[ms] ; A=0456FFFFFFFFFF C=04560000000001 07442: b exchange c[w] ; B=04560000000001 C=04500000000001 07443: b -> c[w] ; C=04560000000001 ; A is displayable. B & C have X value 07444: jsb 0203 ; ; save display value and info in ram[30] 07603: if 0 = s 4 then goto 01607 ; 07607: f -> a ; A=0456FFFFFFFFF1 07610: binary ; 07611: if 0 = s 7 then goto 01617 ; if not dot_pressed (no - stay) 07613: a + 1 -> a[s] ; A=1456FFFFFFFFF1 (flag, A[s]=1) 07614: if 0 = s 4 then goto 01617 ; ; A->ram[30] (A[s] is flag: 1 if dot pressed. A[0]=dot position. Rest: displayable 07617: p <- 1 ; P= 1 07620: load constant 1 ; C=04560000000011 P= 0 07621: c -> addr ; addr=16 07622: a exchange c[w] ; A=04560000000011 C=1456FFFFFFFFF1 07623: c -> data register 14 ; 07624: a exchange c[w] ; A=1456FFFFFFFFF1 C=04560000000011 07625: c -> a[s] ; A=0456FFFFFFFFF1 07626: return ; 07445: ... ; B->C C=04560000000001 07747: ... ; B->C, C->ram[47], P= 0 00323: ... ; B->C, ram[47]->B, P= 0 00115: ... ; 01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14 00120: ... ; ; A=0456FFFFFFFFF1 B=04560000000001 C=04560000000001 ; M1=04500000000016 S=...3.5...9..C..F f=1 00124: ... ; M1=04560000000001 ; C=04560000000001 B=20900000000000 A=0456FFFFFFFF00 P=11 00144: cpu woodstock ; 00145: display off ; 00146: display toggle ; 00147: 0 -> s 15 ; S=...3.5...9..C... 00150: if 1 = s 15 then goto 00147 ; 00152: ...
Press 7
00152: 0 -> s 1 ; 7 pressed (S=...3.5...9..C..F)
00153: 0 -> s 3 ;
00154: if 0 = s 3 then goto 00163 ;
00156: if 0 = s 11 then goto 00165 ;
00165: 0 -> s 5 ;
00166: if 1 = s 5 then goto 00173 ;
00173: if 0 = s 15 then goto 00152 ;
00175: display off ;
00176: ... ; B=04560000000001 C=04560000000000
00222: a -> rom address ; (A=0456FFFFFFF200 P= 1)
key_7:
00440: ... ; S=...3.5...9..CD.F C=04560000000007
digit:
00745: c + 1 -> c[p] ; C=04560000000017 C[1,0]=hex code
00746: ... ; S=...3.5...9..C..F
00565: ... ; A=04560000000017 M1=04560000000017
06024: b -> c[w] ; C=04560000000001
06025: p <- 12 ; P=12
06026: 0 -> s 11 ;
06027: a -> rom address ;
hex_1x:
06001: ... ;
07014: ... ; check 1x, x is 0-9
07164: ... ;
07400: if 1 = s 12 then goto 01417 ;
07417: jsb 0142 ;
; get last display value and settings (decimal point & position) from ram[30]
; put decimal point position in f (4: 0->f, 45: 1->f, 452: 2->f, etc)
; set s7 if dot was pressed already
; fix c[s] given dot_pressed was stored there in ram[30]
07542: p <- 1 ; P= 1
07543: binary ;
07544: load constant 1 ; C=04560000000011 P= 0
07545: c -> addr ;
07546: data register -> c 14 ; C=1456FFFFFFFFF1
07547: a exchange c[p] ; A=04560000000011 C=1456FFFFFFFFF7
07550: f exch a ; (f is 1)
07551: a exchange c[p] ; A=04560000000017 C=1456FFFFFFFFF1
07552: p <- 13 ; P=13
07553: if c[s] = 0 then goto 01601 ;
07555: c - 1 -> c[s] ; C=0456FFFFFFFFF1
07556: if c[s] # 0 then goto 01562 ;
07560: 1 -> s 7 ; S=...3.5.7.9..C..F
07561: if n/c goto 0201 ;
07601: binary ;
07602: return ;
07420: if 1 = s 4 then goto 01510 ;
; shift digit from A[0] to correct position
07422: p <- 1 ; P= 1
07423: c + 1 -> c[p] ; C=0456FFFFFFFF01
07424: if n/c goto 0051 ;
07425: shift left a[w] ; A=45600000000170
07426: p + 1 -> p ; P= 2
07427: if p # 13 then goto 01423 ;
07423: ... ; C=0456FFFFFFF001 A=56000000001700 P= 3
07423: ... ; C=0456FFFFFF0001 A=60000000017000 P= 4
07423: ... ; C=0456FFFFF00001 A=00000000170000 P= 5
07423: ... ; C=0456FFFF000001 A=00000001700000 P= 6
07423: ... ; C=0456FFF0000001 A=00000017000000 P= 7
07423: ... ; C=0456FF00000001 A=00000170000000 P= 8
07423: ... ; C=0456F000000001 A=00001700000000 P= 9
07423: ... ; C=04560000000001 A=00017000000000 P=10
07423: c + 1 -> c[p] ; C=04570000000001
07424: if n/c goto 0051 ;
; exit loop
07451: c - 1 -> c[p] ; C=04560000000001, put value back
07452: if p # 3 then goto 01457 ;
07457: if 1 = s 7 then goto 01431 ; if dot_pressed (yes, go)
;
; NOTE: skipping bit that incremented f with each digit
;
07431: p - 1 -> p ; P= 9
07432: a exchange c[wp] ; A=00010000000001 C=04567000000000
07433: p - 1 -> p ; P= 8
07434: c -> a[w] ; A=04567000000000
07435: c - 1 -> c[wp] ; C=04567FFFFFFFFF
07436: a exchange c[x] ; A=04567000000FFF C=04567FFFFFF000
07437: if a[m] # 0 then goto 01465 ;
07465: jsb 0067 ;
; looks like it adjusts exponent for precision (f) and
; normalizes - don't want C[12] (first digit) =0
07467: a exchange b[x] ; A=04567000000001 B=04560000000FFF
07470: decimal ;
07471: 0 -> a[x] ; A=04567000000000
07472: f -> a ; A=04567000000001 (f still 1)
07473: a + c -> c[x] ; C=04567FFFFFF001 "45.67 blanks"
07474: p <- 12 ; P=12
07475: if c[p] # 0 then goto 01505 ; mantissa in range 1-9, ok
07505: a exchange b[x] ; A=04567000000FFF B=04560000000001
07506: binary ;
07507: return ;
07466: if n/c goto 0041 ;
07441: a exchange c[ms] ; A=04567FFFFFFFFF C=04567000000001
07442: b exchange c[w] ; B=04567000000001 C=04560000000001
07443: b -> c[w] ; C=04567000000001
; A is displayable. B & C have X value
07444: jsb 0203 ;
; save display value and info in ram[30]
07603: ... ; ram[30]=14567FFFFFFFF1 dot_pressed e1
... ; A=04567FFFFFFFF1 C=04567000000011 P= 0
07626: return ;
07445: ... ; B->C, C=04567000000001
07747: ... ; B->C, C->ram[47], P= 0
00323: ... ; B->C, ram[47]->B, P= 0
00115: ... ;
01167: ... ; clear prefixes (s 4,6,7,8,10) and s0,13,14
00120: ...
; A=04567FFFFFFFF1 B=04567000000001 C=04567000000001
; M1=04560000000017 S=...3.5...9..C..F f=1
00124: ...
; M1=04567000000001
; C=04567000000001 B=20900000000000 A=04567FFFFFFF00 P=11
00144: cpu woodstock ;
00145: display off ;
00146: display toggle ;
00147: 0 -> s 15 ; S=...3.5...9..C...
00150: if 1 = s 15 then goto 00147 ;
00152: ...
That was a summary. The real thing (45dot67.txt) is even longer.
I’ve also skipped what happens if you start with dot, press CHS in the middle of the above, or press EEX.
It's only fair to share...
