• Úvodní slovo
• Jednorázové použití
• RPN instrukce jako argumenty na command-line
• RPN instrukce čtené ze souboru
• ML-20
• Lokálni registry
• Náměty na vyzkoušení
• Nápověda
• Utility
• Interaktivní provádění
• Krokování RPN programu
• Okamžité provádění RPN instrukcí
• Bonus

Úvodní slovo

Jak bylo na řadě míst této dokumentace tvrzeno, programová vrstva RPN32 má formu knihovny. K jejímu provozování bude nebytně nutné sestavit program, který zprostředkuje spojení mezi „chlapem, co u toho počitáku sedí“ a výkonnými funkcemi knihovny. (Genderovou disbalanci v minulé větě děvčata jistě ráda prominou. RPN „udělátor“ je opravdu hračkou pouze pro kluky, navíc zdaleka ne pro všechny :-)

Že by čtenář, který po kostrbatých větách doklopýtal až do této části popisu, byl místo sladké odměny nucen k něčemu tak odpudivému jako je programování? Naštěstí ne! Součástí balení je totiž i jednoduchý ukázkový program. Slyší na snadno zapamatovatelné jméno rpn32 a k mání je v obou podobách (zdrojový text i hotový program) v sekci Download. (Na Hané prý používají odborný termín Dulestáhnót. My tak vysoko mířit nebudeme a spokojíme se s méně progresivním označením.)

Následující řádky se budou ostentativně otírat o program rpn32. Bude to místy budit dojem, že předmětem zájmu je právě on. Opak je však pravdou. Tento ukázkový program je pouhým prostředkem k tomu, jak se snadno a rychle knihovně RPN32 dostat oběma rukama pod sukni.

Jednorázové použití

Počítačový program má v zásadě dva druhy životního cyklu:

1. Jednorázové spuštění. Program naběhne, něco spočítá, výsledky vypíše nebo někam uloží a skončí.
2. Trvalý provoz. Program také naběhne (v tom je to úplně stejné :-), ale nikdy neskončí. Místo toho reaguje na podněty zvenčí, což jsou typicky různé události od spolupracujícího HW (např. přenos obrazového datového toku kamery, vyčítání hodnot od teplotních čidel, ...) nebo SW (komunikace s ostatními programy/procesy na stejném či jiném počítači). Pro obě skupiny událostí může za příklad sloužit činnost obsluhy počítače.

RPN instrukce jako argumenty na command-line

Velice operativním použitím je zadání krátké sekvence RPN instrukcí a zpracovávaných (číselných) hodnot ve formě argumentů programu rpn32. Jednoduchý příklad výpočtu početního příkladu  1 + 2 * 3 = 7  vše osvětlí:

#
# rpn32 3 2 x 1 +
RES> 7__________ 0__________ 0__________ 0__________  1__________
#		

POZOR! Instrukce násobení je zapsána jako znak x místo očekávané hvězdičky. Ta by musela být v uvozovkách, aby nebyla nahrazena všemi soubory v aktuálním adresáři. Je to usnadnění zápisu pouze pro tuto formu a je plně v režii programu rpn32. Knihovna o této alternativě neví vůbec nic!

Spuštěný program má 5 argumentů, které jsou všechny RPN instrukcemi. Zde jejich výčet: 3, 2, *, 1, +. O tom je snadné se přesvědčit výpisem programu vzniklého z argumentů:

#
# rpn32 -L 3 2 x 1 +
U:0  3
U:1  2
U:2  *
U:3  1
U:4  +
#		

Jiná podoba téhož může vypadat následovně:

#
# rpn32 -l x + = 1 2 3
U:0  *
U:1  +
RES> 7__________ 0__________ 0__________ 0__________  6__________
#		

Počet argumentů se zvýšil na 6 (-l je option), přesto RPN program obsahuje pouhé dvě instrukce: * a +. Čísla 1, 2, 3 zde nejsou instrukcemi typu přímý operand, ale hodnotami postupně vloženými na RPN stack v tomto pořadí. O tom, co je ještě instrukce a co už je číselná hodnota rozhoduje znak =.

RPN instrukce čtené ze souboru

Druhou možností jak RPN instrukce vpravit do programové vrstvy RPN32 je jejich čtení ze souboru. Je lhostejné, zda se jedná o soubor uložený na disku počítače nebo stream. Každá instrukce tvoří samostatnou programovou řádku zakončenou znakem LF. Příklad s vynásobením dvou čísel a přičtením třetího poslouží i pro tuto variantu.

#
# echo -e "*\n+" >muladd.rpn
#
# cat muladd.rpn
*
+
#
# rpn32 -t -l -mka -rki muladd.rpn 1 2 3
U:0  *
U:1  +
TRC> 3__________ 2__________ 1__________ 0__________  U:0  *
TRC> 6__________ 1__________ 0__________ 0__________  U:1  +
RES> 7__________ 0__________ 0__________ 0__________
#
# rpn32 -t -l -mka -rki - 1 2 3 <muladd.rpn
U:0  *
U:1  +
TRC> 3__________ 2__________ 1__________ 0__________  U:0  *
TRC> 6__________ 1__________ 0__________ 0__________  U:1  +
RES> 7__________ 0__________ 0__________ 0__________
#
# echo -e "*\n+" | rpn32 -t -l -mka -rki - 1 2 3
U:0  *
U:1  +
TRC> 3__________ 2__________ 1__________ 0__________  U:0  *
TRC> 6__________ 1__________ 0__________ 0__________  U:1  +
RES> 7__________ 0__________ 0__________ 0__________
#		

Jednotlivé kroky jsou zřejmé:

• Vytvoření souboru obsahujícího požadovanou sekvenci RPN instrukcí použitím utility echo.
• Zobrazení tohoto souboru utilitou cat.
• Spuštění vytvořeného RPN programu (ze souboru čteného z disku i ze vstupního streamu stdin) se vstupními hodnotami x=3, y=2, z=1 v režimu TRACE (viz option -t a funkce rpn32_run()) s explicitně určenými znaky formátovacího řetězce pro výpisy jednotlivých kroků výpočtu resp. výsledku (viz option -m resp. -r).

» ML-20

A na závěr spuštění RPN programu, který už doopravdy něco spočítá. Jeho původ je velice nepěkný. Jedná se totiž o krádež programu č. 20 z programového modulu Master Library kalkulátorů TI-58/59. Znalcům netřeba připomínat, že se jedná o blok pro

• určení dne v týdnu na základě zadaného data,
• výpočet počtu dní mezi dvěma zadanými daty.

#
# cat ml20.rpn
#==========================================
#           VYPOCET DNE V TYDNU
#==========================================
# X: kompletni udaj YYYYMMDD dekadicky
# Y: nejaky mezivysledek (zustane nezmenen)
lbl0
xeq2
1
-
7
rmd
rtn
#==========================================
#        POCET DNI MEZI DVEMA DATY
#==========================================
# X: kompletni udaj c.1 YYYYMMDD dekadicky
# Y: kompletni udaj c.2 YYYYMMDD dekadicky
lbl1
xeq2
x<>y
xeq 2
-
abs
rtn
#------------------------------------------
#      VYPOCET FAKTORU ZADANEHO DATA
#------------------------------------------
# X: kompletni udaj YYYYMMDD dekadicky
# Y: nejaky mezivysledek (zustane nezmenen)
lbl2
xeq4
rdn
365
rcl*0
  :
  :		

Formou komentáře jsou zvýrazněny dva hlavní vstupní body korespondující s dvěma posláními tohoto programového modulu: LBL 0 (den v týdnu) a LBL 1 (počet dní mezi dvěma daty).

Zajímavé je srovnání obsahu souboru ml20.rpn s výpisem vzniklým zpětným překladem binárního tvaru RPN programu, který byl z něho sestaven. Tentokrát je výpis kompletní, navíc s binárními formami jednotlivých RPN instrukcí. Ty jsou sice k ničemu, ale vypadá to děsně vědecky...

#
# rpn32 -Lac ml20.rpn
0:00  20050000 ________  LBL 0
0:01  20070002 ________  XEQ 2
0:02  8F000001 ________  1
0:03  40090000 ________  -
0:04  8F000007 ________  7
0:05  400C0000 ________  RMD
0:06  40070000 ________  RTN
1:00  20050001 ________  LBL 1
1:01  20070002 ________  XEQ 2
1:02  40010000 ________  x<>y
1:03  20070002 ________  XEQ 2
1:04  40090000 ________  -
1:05  401A0000 ________  ABS
1:06  40070000 ________  RTN
2:00  20050002 ________  LBL 2
2:01  20070004 ________  XEQ 4
2:02  40020000 ________  Rdn
2:03  8F00016D ________  365
2:04  20020000 ________  RCL* 0
2:05  20000002 ________  RCL+ 2
2:06  8F00001F ________  31
2:07  20020001 ________  RCL* 1
2:08  21010004 ________  RCL- L
2:09  40080000 ________  +
2:10  CFFFFFFD ________  -3
2:11  20000001 ________  RCL+ 1
2:12  401B0000 ________  SIGN
2:13  201A0030 ________  x<0?
2:14  20060003 ________  GTO 3
2:15  40020000 ________  Rdn
2:16  8F000004 ________  4
2:17  20020001 ________  RCL* 1
2:18  8F000017 ________  23
2:19  40080000 ________  +
2:20  8F00000A ________  10
2:21  400B0000 ________  /
2:22  40090000 ________  -
2:23  8F000000 ________  0
3:00  20050003 ________  LBL 3
3:01  20000000 ________  RCL+ 0
3:02  210C0003 ________  STO T
3:03  40110000 ________  SR
3:04  40110000 ________  SR
3:05  40080000 ________  +
3:06  40030000 ________  Rup
3:07  8F000064 ________  100
3:08  400B0000 ________  /
3:09  8F000003 ________  3
3:10  400A0000 ________  *
3:11  40060000 ________  LASTx
3:12  40080000 ________  +
3:13  8F000002 ________  2
3:14  40130000 ________  SRn
3:15  40090000 ________  -
3:16  40070000 ________  RTN
4:00  20050004 ________  LBL 4
4:01  200C0000 ________  STO 0
4:02  8F002710 ________  10000
4:03  400B0000 ________  /
4:04  200D0000 ________  x<> 0
4:05  40060000 ________  LASTx
4:06  20020000 ________  RCL* 0
4:07  40090000 ________  -
4:08  200C0001 ________  STO 1
4:09  8F000064 ________  100
4:10  400B0000 ________  /
4:11  200D0001 ________  x<> 1
4:12  40060000 ________  LASTx
4:13  20020001 ________  RCL* 1
4:14  40090000 ________  -
4:15  200C0002 ________  STO 2
4:16  40070000 ________  RTN
#		

Výpis je nápadný ze čtyř důvodů:

1. Zmizely komentáře. Časti programu rpn32 je z programových řádek odstraní ještě před postoupením vrstvě RPN32.
2. Estetický zážitek z vypsaných programových řádek je výrazně vyšší. Samozřejmě i ve zdrojovém souboru ml20.rpn lze psát oddělovací mezery a střídat velká a malá písmena, ale kdo by se s tím mořil.
3. Ani jedna instrukce neleží na adrese začínající literou U. Všechny totiž následují za nějakým návěštím (label).
4. Binární tvar RPN instrukcí nemá ani v jednom z případů dvě slova. Prostě se tam takové instrukce nevyskytují. Jedinou výjimkou by byly instrukce přímých operandů určitého rozsahu.

#
# rpn32 -Lc 173 0xABCDEF 0123456 12345,499,21 021,3
8F0000AD ________  173
AF800000 00ABCDEF  0xABCDEF
9F00A72E ________  0123456
80800000 53E63039  12345,499,21
93060011 ________  0021,3
#		

Je vidět, že přímý operand „rozumné velikosti“ (173 0123456 0021,3) se vejde přímo do operačního kódu instrukce. Ty, které jsou mimo „rozumnou mez“ (0xABCDEF 12345,499,21) jsou samostatně uloženy v následujícím slově.

Ale pojďme zpět k RPN programu ML-20. Stačí ho spustit se zadáním požadovaného data a vhodným formátovacím řetězcem pro výpis výsledku...

#
# rpn32 -rxi ml20.rpn 19790716
RES> 1__________
#		

...a každému je hned jasné, že 16. července 1979 - tedy v den uvedení kalkulátoru HP-41C na trh - bylo pondělí. Výroba „jednačtyřicítky“ skončila někdy v průběhu roku 1990. Předpokládejme, že to bylo poslední den v roce. Opakovaným spuštěním rpn32 s datem ukončení prodeje a option pro start programu od návěští LBL 1 zjistíme, že doba vlády tohoto famózního stroje trvala...

#
# rpn32 -rxi -s1 ml20.rpn 19790716 19901231
>>>> 19901231___ 19790716___ 0__________ 0__________  0__________  1:00  LBL 1
RES> 4186_______
#		

...4186 dní! (Řádkem začínajícím >>>> 19901231___ je signalizováno, že RPN program je spuštěn od adresy 1:00. Bez option -s1 by první prováděnou instrukcí byla ta úplně první v pořadí.)

Lokální registry

Pro ukázku použití lokálních registrů je vybrán jednoduchý příklad: výpočet délky přepony pravoúhlého trojúhelníku s délkami odvěsen zadanými v X- a Y-registru RPN stacku. Výsledek je v X-registru se zopakovaným zadáním v Y- a Z-registru. Ke správnému výsledku zcela jistě povede vzorec  c = √a² + b² . Soubor s RPN programem je obsažen v souboru pyth.rpn. Začněme tedy jeho výpisem. V pravém sloupci jsou úmyslně vloženy prázdné řádky, aby byly obě formy výpisu „řádkově synchronní“.

#
# cat pyth.rpn
#==========================================
#   PYTHAGOROVA VETA - VYPOCET PREPONY
#==========================================
?rtn 1      # rezerva pro lokalni registry
# X=a, Y=b
ipush 2
sto .0
x<>y
sto .1
rcl* x
x<>y
rcl* x
+
x<> .1
rcl .0
rcl .1
pop
gto 10
# X=c, Y=a, Z=b
#==========================================
#         VYPOCET DRUHE ODMOCNINY
#==========================================
lbl 11
1
x<>y
x<=y?
rtn
enter
enter
enter
2
/
lbl 12
/
lastx
+
2
lastx
rdn
/
enter
rup
x<=y?
rtn
rup
enter
rup
gto 12
#------------------------------------------
#       VYPOCET S ULOZENIM REGISTRU
#------------------------------------------
lbl 10
ipush 4
x<> l
sto .0
rdn
sto .1
rdn
sto .2
rdn
sto .3
lastx
xeq 11
x<> .0
sto l
rcl .3
rcl .2
rcl .1
rcl .0
rtn
#					

#
# rpn32 -L pyth.rpn





UU:00  IPUSH 2
UU:01  STO .0
UU:02  x<>y
UU:03  STO .1
UU:04  RCL* X
UU:05  x<>y
UU:06  RCL* X
UU:07  +
UU:08  x<> .1
UU:09  RCL .0
UU:10  RCL .1
UU:11  POP
UU:12  GTO 10




11:00  LBL 11
11:01  1
11:02  x<>y
11:03  x<>=y?
11:04  RTN
11:05  ENTER
11:06  ENTER
11:07  ENTER
11:08  2
11:09  /
12:00  LBL 12
12:01  /
12:02  LASTx
12:03  +
12:04  2
12:05  LASTx
12:06  Rdn
12:07  /
12:08  ENTER
12:09  Rup
12:10  x<>=y?
12:11  RTN
12:12  Rup
12:13  ENTER
12:14  Rup
12:15  GTO 12



10:00  LBL 10
10:01  IPUSH 4
10:02  x<> L
10:03  STO .0
10:04  Rdn
10:05  STO .1
10:06  Rdn
10:07  STO .2
10:08  Rdn
10:09  STO .3
10:10  LASTx
10:11  XEQ 11
10:12  x<> .0
10:13  STO L
10:14  RCL .3
10:15  RCL .2
10:16  RCL .1
10:17  RCL .0
10:18  RTN
#					

Před spuštěním celého výpočtu lze zkusit samotný výpočet druhé odmocniny. Zpracovávaná hodnota je vždy X-registru RPN stacku, ostatní registry jsou naplněny nějakými čísly pro demonstraci jejich případné modifikace.

#
# rpn32 -s11 pyth.rpn 555 444 333 81
>>>> 81_________ 333________ 444________ 555________  0__________  11:00  LBL 11
RES> 9__________ 9__________ 9__________ 81_________  2__________
#
# rpn32 -s10 pyth.rpn 555 444 333 81
>>>> 81_________ 333________ 444________ 555________  0__________  10:00  LBL 10
RES> 9__________ 333________ 444________ 555________  0__________
#		

Nakonec spuštění celého výpočtu.

#
# rpn32 pyth.rpn 3 4
RES> 5__________ 4__________ 3__________ 0__________  16_________
#		

Je to dobré, vyšlo to!  √4² + 3² = 5 .

Zajímavý je „trasovací“ výpis běhu celého programu. Jsou na něm vidět změny obsahů registrů RPN stacku a jejich závěrečná obnova z registrů lokálních. Příkaz pro spuštění programu s trasováním je následující:

#
# rpn32 -t -mkga -r pyth.rpn 999999 3 4
TRC> 4__________ 3__________ 999999_____ 0__________  0,0  UU:00  IPUSH 2
TRC> 4__________ 3__________ 999999_____ 0__________  2,2  UU:01  STO .0
TRC> 4__________ 3__________ 999999_____ 0__________  2,2  UU:02  x<>y
TRC> 3__________ 4__________ 999999_____ 0__________  2,2  UU:03  STO .1
  :
  :
TRC> 999999_____ 16_________ 5__________ 5__________  4,4  10:15  RCL .2
TRC> 3__________ 999999_____ 16_________ 5__________  4,4  10:16  RCL .1
TRC> 4__________ 3__________ 999999_____ 16_________  4,4  10:17  RCL .0
TRC> 5__________ 4__________ 3__________ 999999_____  4,4  10:18  RTN
RES> 5__________ 4__________ 3__________ 999999_____  0,0  UU:00  IPUSH 2
#		

Za pozornost také stojí sloupec indikující využití zásobníku lokálních registrů (viz příslušný znak ve formátovacím řetězci): První číslo udává počet v aktuální úrovni (typicky pro právě prováděný podprogram), druhé celkovou míru zaplnění. Pomůckou pro zapamatování pořadí údajů může být podobnost se zlomkem - aktuální=čitatel, celkový=jmenovatel. Názornější ukázka výpisu využití zásobníku následuje. Program sice nedělá vůbec nic, ale změny hodnot během jeho provádění vše vysvětlují:

#
# rpn32 -mxga -t -r 4 push xeq0 pse rtn lbl0 ipush2 xeq1 pop xeq1 rtn lbl1 3 push pse rtn ?rtn5
TRC> 0__________  0,0  U:0  4
TRC> 4__________  0,0  U:1  PUSH
TRC> 0__________  4,4  U:2  XEQ 0
TRC> 0__________  0,4  0:0  LBL 0
TRC> 0__________  0,4  0:1  IPUSH 2
TRC> 0__________  2,6  0:2  XEQ 1
TRC> 0__________  0,6  1:0  LBL 1
TRC> 0__________  0,6  1:1  3
TRC> 3__________  0,6  1:2  PUSH
TRC> 0__________  3,9  1:3  PSE
TRC> 0__________  3,9  1:4  RTN
TRC> 0__________  2,6  0:3  POP
TRC> 0__________  0,4  0:4  XEQ 1
TRC> 0__________  0,4  1:0  LBL 1
TRC> 0__________  0,4  1:1  3
TRC> 3__________  0,4  1:2  PUSH
TRC> 0__________  3,7  1:3  PSE
TRC> 0__________  3,7  1:4  RTN
TRC> 0__________  0,4  0:5  RTN
TRC> 0__________  4,4  U:3  PSE
TRC> 0__________  4,4  U:4  RTN
RES> 0__________  0,0  U:0  4
#		

Náměty na vyzkoušení

» Nápověda

Několik ilustrativních námětů poskytuje také nápověda programu rpn32:

#
# rpn32 -h
Use:
# rpn32 [options] pl1 [pl2 [ ... plN]] [= [[[regT] regZ] regY] regX] [=]
# rpn32 [options] filename               [[[[regT] regZ] regY] regX] [=]
  :
  :
Examples:
  :
  :
# rpn32 -muhXsdXuhLsdL0,1@0@1a -t example.rpn
# rpn32 sto0 lbl0 rcl0 count pse isg0 gto0 = 4,18,2
# rpn32 lcn sto0 lbl0 rcl0 count pse isg0 gto0 = 2 18 4
# rpn32 "-m\c\o\un\t\d\own\=0i" -r sto0 lbl0 pse dsz0 gto0 = 6
# rpn32 example.rpn =
# rpn32 + "*" = 12 0xAD 077 =
# rpn32 =
# rpn32 ?reg19 =
# substi <battery.rpn | rpn32 -t -s20 - = 36
#		

Program substi z posledního příkladu je popsán zde.

» Utility

V některých případech použití programu rpn32 vznikne potřeba změnit (modifikovat) jeho výpis/výstup nad rámec možností formátovacího řetězce.

Příklad: Z výpisu režimu TRACE je potřeba vytvořit soubor s požadovaným formátováním. Znamená to:

1. Akceptovat pouze řádky uvozené prefixem TRC>. Zároveň tento prefix z výpisu odstranit.
2. Vzniklé sloupce výpisu oddělovat tabulátory místo dvojicemi mezer.
3. U číselných hodnot odstranit koncové/výpňové znaky podtržení.

#
# rpn32 -mxyztla -t ml20.rpn 19790716 | grep TRC\> | sed "s/  /`echo -e '\t'`/g" | sed "s/_//g" | sed "s/^.... //g" >tracelist.txt
# hd tracelist.txt
0000000: 31 39 37 39 30 37 31 36 09 30 09 30 09 30 09 30 19790716.0.0.0.0
0000010: 09 30 3a 30 30 09 4c 42 4c 20 30 0a 31 39 37 39 .0:00.LBL 0.1979
0000020: 30 37 31 36 09 30 09 30 09 30 09 30 09 30 3a 30 0716.0.0.0.0.0:0
0000030: 31 09 58 45 51 20 32 0a 31 39 37 39 30 37 31 36 1.XEQ 2.19790716
  :
  :
0000660: 32 33 30 31 30 09 30 09 30 09 30 09 31 09 30 3a 23010.0.0.0.1.0:
0000670: 30 34 09 37 0a 37 09 37 32 33 30 31 30 09 30 09 04.7.7.723010.0.
0000680: 30 09 31 09 30 3a 30 35 09 52 4d 44 0a 31 09 30 0.1.0:05.RMD.1.0
0000690: 09 30 09 30 09 37 09 30 3a 30 36 09 52 54 4e 0a .0.0.7.0:06.RTN.
#		

Interaktivní provádění

Jedna z úvodních kapiol této dokumentace vyzdvihuje úžasnou vlastnost, kterou předchozí řešení RPNPROC obdařeno nebylo: schopnost okamžitého provádění RPN instrukcí zadaných v textové formě (viz funkce rpn32_now()). Navíc, ukázkový program rpn32 obsahuje vtipnou konstrukci využívající callback funkce rpn32_run() k vytvoření mechanismu pro krokování RPN programu (tzv. Single step). Velice účinnou zbraní je kombinace použití obou prostředků: okamžité provádění a krokování.

Krokování RPN programu

RPN program lze provádět instrukci po instrukci, tedy krokovat. Kalkulátory z provenience HP nebo TI (a možná i jiné) měly tuto funkci skrytou pod tlačítkem SST (Single step). Krokování RPN programu lze ukázat na jednom z příkladů nabízených nápovědou programu rpn32.

#
# rpn32 -m0i -r sto0 lbl0 pse dsz0 gto0 = 6 =
CMD> lst
U:0  STO 0
0:0  LBL 0
0:1  PSE
0:2  DSZ 0
0:3  GTO 0
CMD>
>>>> 6__________ 0__________ 0__________ 0__________  0__________  U:0  STO 0
CMD> mod0i
CMD> run-
PSE> 6__________
PSE> 5__________
PSE> 4__________
PSE> 3__________
PSE> 2__________
PSE> 1__________
RES> 0__________
CMD> mod0a
CMD> sst
>>>> 0__________  U:0  STO 0
SST>
>>>> 6__________  0:0  LBL 0
SST>
>>>> 6__________  0:1  PSE
SST>
>>>> 6__________  0:2  DSZ 0
SST>
>>>> 5__________  0:3  GTO 0
SST>
>>>> 5__________  0:0  LBL 0
SST>
>>>> 5__________  0:1  PSE
SST>
>>>> 5__________  0:2  DSZ 0
SST>
>>>> 4__________  0:3  GTO 0
SST>
>>>> 4__________  0:0  LBL 0
SST>
>>>> 4__________  0:1  PSE
SST>
>>>> 4__________  0:2  DSZ 0
SST>
>>>> 3__________  0:3  GTO 0
SST>
>>>> 3__________  0:0  LBL 0
SST>
>>>> 3__________  0:1  PSE
SST>
>>>> 3__________  0:2  DSZ 0
SST> run
TRC> 3__________  0:2  DSZ 0
TRC> 2__________  0:3  GTO 0
TRC> 2__________  0:0  LBL 0
TRC> 2__________  0:1  PSE
TRC> 2__________  0:2  DSZ 0
TRC> 1__________  0:3  GTO 0
TRC> 1__________  0:0  LBL 0
TRC> 1__________  0:1  PSE
TRC> 1__________  0:2  DSZ 0
RES> 0__________  U:0  STO 0
CMD> mod
MOD> 0a
CMD> spyka
>>>> 6__________ 0__________ 0__________ 0__________  U:0  STO 0
CMD> bye
#		

Co je z předchozího výpisu vidět? Spuštěný program rpn32 čeká na vstup z klávesnice, což dává na srozuměnou promptem CMD>. (Čekání ve stavu Command je důsledkem posledního argumentu na command-line, znaku =.) Následují odezvy na příkazy tvořené trojznakovými zkratkami:

• Po zadání příkazu lst dojde k výpisu všech RPN instrukcí.
• Prázdný příkaz (pouhý stisk klávesy Enter) je ekvivalentem příkazu spy bez parametrů. Vypíše aktuální stav interpreteru.
• Argument 0i příkazu mod nastaví znaky formátovacího řetězce pro následující výpisy.
• Příkaz run s argumentem - spustí běh RPN programu. Argument potlačí režim TRACE.
• Opakované zadání mod tentokrát s argumentem 0a patřičně přizpůsobí následující výpisy.
• Konečně přišel na řadu dlouho očekávaný příkaz sst. Vypíše aktuální stav interpreteru (zvláště zajímavé jsou dva údaje: adresa a mnemonický tvar instrukce). Zároveň přejde do „čekacího“ stavu Single step s odpovídající změnou promptu na SST>.
• Opakovaný prázdný příkaz (pouze klávesa Enter) ve stavu Single step provádí krokování bez nutnosti stále vepisovat text příkazu sst. Z výpisů je názorně vidět po jakých adresách a programových řádkách RPN program „kráčí“. U tak jednoduchého příkladu nelze očekávat, že by to někoho bavilo déle, než naznačuje ilustrativní výpis. Proto je neodvratnému poznání „...dyť je to jak u blbejch!“ předejito zadáním následujícího příkazu.
• Trápení je skončeno a příkaz run spustí provádění zbytku RPN programu „na plný plyn“, navíc v režimu TRACE. Je vidět, že stav Single step byl ukončen návratem do výchozího stavu Command.
• Příkaz spy s argumentem ka nás ubezpečí, že šestka v X-registru RPN stacku celé běsnění bez úhony přečkala. Argument ka bylo nutné zadat. Předchozí dotaz v podobě příkazu mod jasně říká, že X-registr ve formátovacím řetězci zastoupen není.
• Závěrečným příkazem bye celá odysea končí. (Borci, co to znají, mohou stisknout Ctrl-D (pošlou tím EOF do stdin). A když program rpn32 „drsně sejmou“ stiskem Ctrl-C, určitě skončí taky :-)

#
# rpn32 sto0 lbl0 pse dsz0 gto0 = 6 =
CMD> mod
MOD> sdkLa
CMD> spy
>>>> 6__________ 0__________ 0__________ 0__________  0__________  U:0  STO 0
CMD> sst0a
>>>> 0__________  U:0  STO 0
SST>
>>>> 6__________  0:0  LBL 0
SST>
>>>> 6__________  0:1  PSE
SST>
>>>> 6__________  0:2  DSZ 0
SST>
>>>> 5__________  0:3  GTO 0
SST> cmd
CMD> spy
>>>> 6__________ 0__________ 0__________ 0__________  0__________  0:3  GTO 0
CMD> bye
#		

Okamžité provádění RPN instrukcí

Vnitřní proměnné vrstvy RPN32 nemusejí (po inicializaci) obsahovat žádnou sekvenci RPN instrukcí tvořících RPN program (či více programů). Přesto je možné provádět operace s registry RPN stacku, paměťovými registry i flags. Jinak řečeno, libovolnou RPN instrukci lze vykonat jednotlivě/jednorázově nezávisle na programové paměti.

Pojďme se, pro jistotu, ještě jednou přesvědčit, že  1 + 2 * 3 = 7 . Tentokrát bez automatiky, ale pěkně postaru - ručně.

#
# rpn32 =
CMD> spy
>>>> 0__________ 0__________ 0__________ 0__________  0__________
CMD> mod\X\=x\Y\=y\L\a\s\t\X\=l
CMD> spy
>>>> X=0__________  Y=0__________  LastX=0__________
CMD> 2
>>>> X=2__________  Y=0__________  LastX=0__________
CMD> 3
>>>> X=3__________  Y=2__________  LastX=0__________
CMD> *
>>>> X=6__________  Y=0__________  LastX=3__________
CMD> 1
>>>> X=1__________  Y=6__________  LastX=3__________
CMD> +
>>>> X=7__________  Y=0__________  LastX=1__________
CMD>	

Je to dobré, vyšlo to! To ale není jediné, co stojí za pozornost. Ve výpisech se ani přes sofistikovaně sestavený formátovací řetězec neobjeví adresa ani a mnemonický tvar nějaké instrukce. Dá se to pochopit: komu není program, tomu není výpis instrukce. (Cimrmanologové by možná dali přednost jiné parafrázi: „Tak! Ale teď už se opravdu program stranou, tohleto. Už mě to namouduši žádná instrukce!“)

Závěrečná třešnička na dortu není ničím jiným, než koktejlem namíchaným z těchto ingrediencí:

připravený RPN program   +   krokování   +   okamžité provádění.

K předvedení nacvičené sestavy se bezvadně hodí program ML-20. Jeho část pro rozdělení zadaného data do paměťových registrů 0:YYYY, 1:MM a 2:DD bude obsluhována ručně.

#
# rpn32 ml20.rpn =
CMD> modxy0,1,2a
CMD> 19790716
>>>> 19790716___  0__________  0__________  0__________  0__________  0:00  LBL 0
CMD> gto4
>>>> 19790716___  0__________  0__________  0__________  0__________  4:00  LBL 4
CMD> sst
>>>> 19790716___  0__________  0__________  0__________  0__________  4:00  LBL 4
SST>
>>>> 19790716___  0__________  0__________  0__________  0__________  4:01  STO 0
SST>
>>>> 19790716___  0__________  19790716___  0__________  0__________  4:02  10000
SST>
>>>> 10000______  19790716___  19790716___  0__________  0__________  4:03  /
SST>
>>>> 1979_______  0__________  19790716___  0__________  0__________  4:04  x<> 0
SST>
>>>> 19790716___  0__________  1979_______  0__________  0__________  4:05  LASTx
SST>
>>>> 10000______  19790716___  1979_______  0__________  0__________  4:06  RCL* 0
SST>
>>>> 19790000___  19790716___  1979_______  0__________  0__________  4:07  -
SST>
>>>> 716________  0__________  1979_______  0__________  0__________  4:08  STO 1
SST>
>>>> 716________  0__________  1979_______  716________  0__________  4:09  100
SST>
>>>> 100________  716________  1979_______  716________  0__________  4:10  /
SST>
>>>> 7__________  0__________  1979_______  716________  0__________  4:11  x<> 1
SST>
>>>> 716________  0__________  1979_______  7__________  0__________  4:12  LASTx
SST>
>>>> 100________  716________  1979_______  7__________  0__________  4:13  RCL* 1
SST>
>>>> 700________  716________  1979_______  7__________  0__________  4:14  -
SST>
>>>> 16_________  0__________  1979_______  7__________  0__________  4:15  STO 2
SST>
>>>> 16_________  0__________  1979_______  7__________  16_________  4:16  RTN
SST>
CMD> bye
#		

Možná to tak nevypadá, ale všechny slibované přísady jsou přítomny.

# rpn32 ml20.rpn =
CMD>				

CMD> sst
SST>				

CMD> 19790716
CMD> gto4		

» Bonus

Při okamžitém provádění RPN instrukcí (nikdy ne v rámci RPN programu) mohou instrukce GTO a XEQ mít ve svém operandu číslo návěští doplněné číslem řádky:

#
# rpn32 ml20.rpn =
CMD> lst
0:00  LBL 0
0:01  XEQ 2
0:02  1
0:03  -
  :
  :
3:14  SRn
3:15  -
3:16  RTN
4:00  LBL 4
4:01  STO 0
4:02  10000
4:03  /
4:04  x<> 0
4:05  LASTx
4:06  RCL* 0
  :
  :
4:15  STO 2
4:16  RTN
CMD> spy
>>>> 0__________ 0__________ 0__________ 0__________  0__________  0:00  LBL 0
CMD> gto4:5
>>>> 0__________ 0__________ 0__________ 0__________  0__________  4:05  LASTx
CMD>