AVRASM ver. 2.1.52 leonardo.asm Sun Apr 30 20:10:13 2017 leonardo.asm(5): Including file '../../avr8\preamble.inc' ../../avr8\preamble.inc(2): Including file '../../avr8\macros.asm' ../../avr8\macros.asm(6): Including file '../../avr8\user.inc' ../../avr8\preamble.inc(6): Including file '../../avr8/devices/atmega32u4\device.asm' ../../avr8/devices/atmega32u4\device.asm(5): Including file '../../avr8/Atmel/Appnotes2\m32U4def.inc' leonardo.asm(13): Including file '../../avr8\drivers/usart_1.asm' ../../avr8\drivers/usart_1.asm(31): Including file '../../avr8\drivers/usart_common.asm' ../../avr8\drivers/usart_common.asm(11): Including file '../../avr8\drivers/usart-rx-buffer.asm' ../../avr8\drivers/usart_common.asm(24): Including file '../../avr8\words/usart-tx-poll.asm' ../../avr8\drivers/usart_common.asm(29): Including file '../../avr8\words/ubrr.asm' ../../avr8\drivers/usart_common.asm(30): Including file '../../avr8\words/usart.asm' leonardo.asm(15): Including file '../../avr8\amforth.asm' ../../avr8\amforth.asm(12): Including file '../../avr8\drivers/generic-isr.asm' ../../avr8\amforth.asm(14): Including file '../../avr8\dict/rww.inc' ../../avr8\dict/rww.inc(1): Including file '../../avr8\words/mplus.asm' ../../avr8\dict/rww.inc(2): Including file '../../common\words/ud-star.asm' ../../avr8\dict/rww.inc(3): Including file '../../common\words/umax.asm' ../../avr8\dict/rww.inc(4): Including file '../../common\words/umin.asm' ../../avr8\dict/rww.inc(5): Including file '../../avr8\words/immediate-q.asm' ../../avr8\dict/rww.inc(6): Including file '../../avr8\words/name2flags.asm' ../../avr8\dict/rww.inc(11): Including file '../../avr8\dict/appl_4k.inc' ../../avr8\dict/appl_4k.inc(1): Including file '../../common\words/ver.asm' ../../avr8\dict/appl_4k.inc(4): Including file '../../common\words/noop.asm' ../../avr8\dict/appl_4k.inc(5): Including file '../../avr8\words/unused.asm' ../../avr8\dict/appl_4k.inc(6): Including file '../../common\words/to.asm' ../../avr8\dict/appl_4k.inc(7): Including file '../../avr8\words/i-cellplus.asm' ../../avr8\dict/appl_4k.inc(8): Including file '../../avr8\words/icompare.asm' ../../avr8\dict/appl_4k.inc(9): Including file '../../common\words/star.asm' ../../avr8\dict/appl_4k.inc(10): Including file '../../avr8\words/j.asm' ../../avr8\dict/appl_4k.inc(11): Including file '../../avr8\words/dabs.asm' ../../avr8\dict/appl_4k.inc(12): Including file '../../avr8\words/dnegate.asm' ../../avr8\dict/appl_4k.inc(13): Including file '../../avr8\words/cmove.asm' ../../avr8\dict/appl_4k.inc(14): Including file '../../common\words/2swap.asm' ../../avr8\dict/appl_4k.inc(15): Including file '../../common\words/tib.asm' ../../avr8\dict/appl_4k.inc(16): Including file '../../avr8\words/init-ram.asm' ../../avr8\dict/appl_4k.inc(20): Including file '../../avr8\words/environment.asm' ../../avr8\dict/appl_4k.inc(21): Including file '../../avr8\words/env-wordlists.asm' ../../avr8\dict/appl_4k.inc(22): Including file '../../avr8\words/env-slashpad.asm' ../../avr8\dict/appl_4k.inc(23): Including file '../../common\words/env-slashhold.asm' ../../avr8\dict/appl_4k.inc(24): Including file '../../common\words/env-forthname.asm' ../../avr8\dict/appl_4k.inc(25): Including file '../../common\words/env-forthversion.asm' ../../avr8\dict/appl_4k.inc(26): Including file '../../common\words/env-cpu.asm' ../../avr8\dict/appl_4k.inc(27): Including file '../../avr8\words/env-mcuinfo.asm' ../../avr8\dict/appl_4k.inc(28): Including file '../../common\words/env-usersize.asm' ../../avr8\dict/appl_4k.inc(30): Including file '../../avr8\words/hld.asm' ../../avr8\dict/appl_4k.inc(31): Including file '../../common\words/hold.asm' ../../avr8\dict/appl_4k.inc(32): Including file '../../common\words/less-sharp.asm' ../../avr8\dict/appl_4k.inc(33): Including file '../../common\words/sharp.asm' ../../avr8\dict/appl_4k.inc(34): Including file '../../common\words/sharp-s.asm' ../../avr8\dict/appl_4k.inc(35): Including file '../../common\words/sharp-greater.asm' ../../avr8\dict/appl_4k.inc(36): Including file '../../common\words/sign.asm' ../../avr8\dict/appl_4k.inc(37): Including file '../../common\words/d-dot-r.asm' ../../avr8\dict/appl_4k.inc(38): Including file '../../common\words/dot-r.asm' ../../avr8\dict/appl_4k.inc(39): Including file '../../common\words/d-dot.asm' ../../avr8\dict/appl_4k.inc(40): Including file '../../common\words/dot.asm' ../../avr8\dict/appl_4k.inc(41): Including file '../../common\words/ud-dot.asm' ../../avr8\dict/appl_4k.inc(42): Including file '../../common\words/ud-dot-r.asm' ../../avr8\dict/appl_4k.inc(43): Including file '../../common\words/ud-slash-mod.asm' ../../avr8\dict/appl_4k.inc(44): Including file '../../common\words/digit-q.asm' ../../avr8\dict/appl_4k.inc(46): Including file '../../avr8\words/do-sliteral.asm' ../../avr8\dict/appl_4k.inc(47): Including file '../../avr8\words/scomma.asm' ../../avr8\dict/appl_4k.inc(48): Including file '../../avr8\words/itype.asm' ../../avr8\dict/appl_4k.inc(49): Including file '../../avr8\words/icount.asm' ../../avr8\dict/appl_4k.inc(50): Including file '../../common\words/type.asm' ../../avr8\dict/appl_4k.inc(51): Including file '../../common\words/tick.asm' ../../avr8\dict/appl_4k.inc(53): Including file '../../common\words/cskip.asm' ../../avr8\dict/appl_4k.inc(54): Including file '../../common\words/cscan.asm' ../../avr8\dict/appl_4k.inc(55): Including file '../../common\words/accept.asm' ../../avr8\dict/appl_4k.inc(56): Including file '../../common\words/refill.asm' ../../avr8\dict/appl_4k.inc(57): Including file '../../common\words/char.asm' ../../avr8\dict/appl_4k.inc(58): Including file '../../common\words/number.asm' ../../avr8\dict/appl_4k.inc(59): Including file '../../common\words/q-sign.asm' ../../avr8\dict/appl_4k.inc(60): Including file '../../common\words/set-base.asm' ../../avr8\dict/appl_4k.inc(61): Including file '../../common\words/to-number.asm' ../../avr8\dict/appl_4k.inc(62): Including file '../../common\words/parse.asm' ../../avr8\dict/appl_4k.inc(63): Including file '../../common\words/source.asm' ../../avr8\dict/appl_4k.inc(64): Including file '../../common\words/slash-string.asm' ../../avr8\dict/appl_4k.inc(65): Including file '../../common\words/parse-name.asm' ../../avr8\dict/appl_4k.inc(66): Including file '../../avr8\words/sp0.asm' ../../avr8\dict/appl_4k.inc(67): Including file '../../avr8\words/rp0.asm' ../../avr8\dict/appl_4k.inc(68): Including file '../../common\words/depth.asm' ../../avr8\dict/appl_4k.inc(69): Including file '../../avr8\words/forth-recognizer.asm' ../../avr8\dict/appl_4k.inc(70): Including file '../../common\words/recognize.asm' ../../avr8\dict/appl_4k.inc(71): Including file '../../common\words/interpret.asm' ../../avr8\dict/appl_4k.inc(72): Including file '../../common\words/rec-intnum.asm' ../../avr8\dict/appl_4k.inc(73): Including file '../../common\words/rec-find.asm' ../../avr8\dict/appl_4k.inc(74): Including file '../../common\words/dt-null.asm' ../../avr8\dict/appl_4k.inc(75): Including file '../../common\words/search-wordlist.asm' ../../avr8\dict/appl_4k.inc(76): Including file '../../common\words/traverse-wordlist.asm' ../../avr8\dict/appl_4k.inc(77): Including file '../../common\words/name2string.asm' ../../avr8\dict/appl_4k.inc(78): Including file '../../avr8\words/nfa2cfa.asm' ../../avr8\dict/appl_4k.inc(79): Including file '../../common\words/find-xt.asm' ../../avr8\dict/appl_4k.inc(81): Including file '../../avr8\dict/compiler1.inc' ../../avr8\dict/compiler1.inc(2): Including file '../../avr8\words/newest.asm' ../../avr8\dict/compiler1.inc(3): Including file '../../avr8\words/latest.asm' ../../avr8\dict/compiler1.inc(4): Including file '../../common\words/do-create.asm' ../../avr8\dict/compiler1.inc(5): Including file '../../common\words/backslash.asm' ../../avr8\dict/compiler1.inc(6): Including file '../../common\words/l-paren.asm' ../../avr8\dict/compiler1.inc(8): Including file '../../common\words/compile.asm' ../../avr8\dict/compiler1.inc(9): Including file '../../avr8\words/comma.asm' ../../avr8\dict/compiler1.inc(10): Including file '../../common\words/brackettick.asm' ../../avr8\dict/compiler1.inc(13): Including file '../../common\words/literal.asm' ../../avr8\dict/compiler1.inc(14): Including file '../../common\words/sliteral.asm' ../../avr8\dict/compiler1.inc(15): Including file '../../avr8\words/g-mark.asm' ../../avr8\dict/compiler1.inc(16): Including file '../../avr8\words/g-resolve.asm' ../../avr8\dict/compiler1.inc(17): Including file '../../avr8\words/l_mark.asm' ../../avr8\dict/compiler1.inc(18): Including file '../../avr8\words/l_resolve.asm' ../../avr8\dict/compiler1.inc(20): Including file '../../common\words/ahead.asm' ../../avr8\dict/compiler1.inc(21): Including file '../../common\words/if.asm' ../../avr8\dict/compiler1.inc(22): Including file '../../common\words/else.asm' ../../avr8\dict/compiler1.inc(23): Including file '../../common\words/then.asm' ../../avr8\dict/compiler1.inc(24): Including file '../../common\words/begin.asm' ../../avr8\dict/compiler1.inc(25): Including file '../../common\words/while.asm' ../../avr8\dict/compiler1.inc(26): Including file '../../common\words/repeat.asm' ../../avr8\dict/compiler1.inc(27): Including file '../../common\words/until.asm' ../../avr8\dict/compiler1.inc(28): Including file '../../common\words/again.asm' ../../avr8\dict/compiler1.inc(29): Including file '../../common\words/do.asm' ../../avr8\dict/compiler1.inc(30): Including file '../../common\words/loop.asm' ../../avr8\dict/compiler1.inc(31): Including file '../../common\words/plusloop.asm' ../../avr8\dict/compiler1.inc(32): Including file '../../common\words/leave.asm' ../../avr8\dict/compiler1.inc(33): Including file '../../common\words/qdo.asm' ../../avr8\dict/compiler1.inc(34): Including file '../../common\words/endloop.asm' ../../avr8\dict/compiler1.inc(36): Including file '../../common\words/l-from.asm' ../../avr8\dict/compiler1.inc(37): Including file '../../common\words/to-l.asm' ../../avr8\dict/compiler1.inc(38): Including file '../../avr8\words/lp0.asm' ../../avr8\dict/compiler1.inc(39): Including file '../../avr8\words/lp.asm' ../../avr8\dict/compiler1.inc(41): Including file '../../common\words/create.asm' ../../avr8\dict/compiler1.inc(42): Including file '../../avr8\words/header.asm' ../../avr8\dict/compiler1.inc(43): Including file '../../avr8\words/wlscope.asm' ../../avr8\dict/compiler1.inc(44): Including file '../../common\words/reveal.asm' ../../avr8\dict/compiler1.inc(45): Including file '../../avr8\words/does.asm' ../../avr8\dict/compiler1.inc(46): Including file '../../common\words/colon.asm' ../../avr8\dict/compiler1.inc(47): Including file '../../avr8\words/colon-noname.asm' ../../avr8\dict/compiler1.inc(48): Including file '../../common\words/semicolon.asm' ../../avr8\dict/compiler1.inc(49): Including file '../../common\words/right-bracket.asm' ../../avr8\dict/compiler1.inc(50): Including file '../../common\words/left-bracket.asm' ../../avr8\dict/compiler1.inc(51): Including file '../../common\words/variable.asm' ../../avr8\dict/compiler1.inc(52): Including file '../../common\words/constant.asm' ../../avr8\dict/compiler1.inc(53): Including file '../../avr8\words/user.asm' ../../avr8\dict/compiler1.inc(55): Including file '../../common\words/recurse.asm' ../../avr8\dict/compiler1.inc(56): Including file '../../avr8\words/immediate.asm' ../../avr8\dict/compiler1.inc(58): Including file '../../common\words/bracketchar.asm' ../../avr8\dict/compiler1.inc(59): Including file '../../common\words/abort-string.asm' ../../avr8\dict/compiler1.inc(60): Including file '../../common\words/abort.asm' ../../avr8\dict/compiler1.inc(61): Including file '../../common\words/q-abort.asm' ../../avr8\dict/compiler1.inc(63): Including file '../../common\words/get-stack.asm' ../../avr8\dict/compiler1.inc(64): Including file '../../common\words/set-stack.asm' ../../avr8\dict/compiler1.inc(65): Including file '../../common\words/map-stack.asm' ../../avr8\dict/compiler1.inc(66): Including file '../../avr8\words/get-current.asm' ../../avr8\dict/compiler1.inc(67): Including file '../../common\words/get-order.asm' ../../avr8\dict/compiler1.inc(68): Including file '../../common\words/cfg-order.asm' ../../avr8\dict/compiler1.inc(69): Including file '../../avr8\words/compare.asm' ../../avr8\dict/compiler1.inc(70): Including file '../../avr8\words/nfa2lfa.asm' ../../avr8\amforth.asm(15): Including file 'dict_appl.inc' dict_appl.inc(4): Including file '../../avr8\dict/compiler2.inc' ../../avr8\dict/compiler2.inc(8): Including file '../../avr8\words/set-current.asm' ../../avr8\dict/compiler2.inc(9): Including file '../../avr8\words/wordlist.asm' ../../avr8\dict/compiler2.inc(11): Including file '../../avr8\words/forth-wordlist.asm' ../../avr8\dict/compiler2.inc(12): Including file '../../common\words/set-order.asm' ../../avr8\dict/compiler2.inc(13): Including file '../../common\words/set-recognizer.asm' ../../avr8\dict/compiler2.inc(14): Including file '../../common\words/get-recognizer.asm' ../../avr8\dict/compiler2.inc(15): Including file '../../avr8\words/code.asm' ../../avr8\dict/compiler2.inc(16): Including file '../../avr8\words/end-code.asm' ../../avr8\dict/compiler2.inc(17): Including file '../../avr8\words/marker.asm' ../../avr8\dict/compiler2.inc(18): Including file '../../common\words/postpone.asm' dict_appl.inc(6): Including file 'words/applturnkey.asm' ../../avr8\amforth.asm(23): Including file '../../avr8\amforth-interpreter.asm' ../../avr8\amforth.asm(24): Including file '../../avr8\dict/nrww.inc' ../../avr8\dict/nrww.inc(4): Including file '../../avr8\words/exit.asm' ../../avr8\dict/nrww.inc(5): Including file '../../avr8\words/execute.asm' ../../avr8\dict/nrww.inc(6): Including file '../../avr8\words/dobranch.asm' ../../avr8\dict/nrww.inc(7): Including file '../../avr8\words/docondbranch.asm' ../../avr8\dict/nrww.inc(10): Including file '../../avr8\words/doliteral.asm' ../../avr8\dict/nrww.inc(11): Including file '../../avr8\words/dovariable.asm' ../../avr8\dict/nrww.inc(12): Including file '../../avr8\words/doconstant.asm' ../../avr8\dict/nrww.inc(13): Including file '../../avr8\words/douser.asm' ../../avr8\dict/nrww.inc(14): Including file '../../avr8\words/do-value.asm' ../../avr8\dict/nrww.inc(15): Including file '../../avr8\words/fetch.asm' ../../avr8\dict/nrww.inc(16): Including file '../../avr8\words/store.asm' ../../avr8\dict/nrww.inc(17): Including file '../../avr8\words/cstore.asm' ../../avr8\dict/nrww.inc(18): Including file '../../avr8\words/cfetch.asm' ../../avr8\dict/nrww.inc(19): Including file '../../avr8\words/fetch-u.asm' ../../avr8\dict/nrww.inc(20): Including file '../../avr8\words/store-u.asm' ../../avr8\dict/nrww.inc(23): Including file '../../avr8\words/dup.asm' ../../avr8\dict/nrww.inc(24): Including file '../../avr8\words/qdup.asm' ../../avr8\dict/nrww.inc(25): Including file '../../avr8\words/swap.asm' ../../avr8\dict/nrww.inc(26): Including file '../../avr8\words/over.asm' ../../avr8\dict/nrww.inc(27): Including file '../../avr8\words/drop.asm' ../../avr8\dict/nrww.inc(28): Including file '../../avr8\words/rot.asm' ../../avr8\dict/nrww.inc(29): Including file '../../avr8\words/nip.asm' ../../avr8\dict/nrww.inc(31): Including file '../../avr8\words/r_from.asm' ../../avr8\dict/nrww.inc(32): Including file '../../avr8\words/to_r.asm' ../../avr8\dict/nrww.inc(33): Including file '../../avr8\words/r_fetch.asm' ../../avr8\dict/nrww.inc(36): Including file '../../common\words/not-equal.asm' ../../avr8\dict/nrww.inc(37): Including file '../../avr8\words/equalzero.asm' ../../avr8\dict/nrww.inc(38): Including file '../../avr8\words/lesszero.asm' ../../avr8\dict/nrww.inc(39): Including file '../../avr8\words/greaterzero.asm' ../../avr8\dict/nrww.inc(40): Including file '../../avr8\words/d-greaterzero.asm' ../../avr8\dict/nrww.inc(41): Including file '../../avr8\words/d-lesszero.asm' ../../avr8\dict/nrww.inc(43): Including file '../../avr8\words/true.asm' ../../avr8\dict/nrww.inc(44): Including file '../../avr8\words/zero.asm' ../../avr8\dict/nrww.inc(45): Including file '../../avr8\words/uless.asm' ../../avr8\dict/nrww.inc(46): Including file '../../common\words/u-greater.asm' ../../avr8\dict/nrww.inc(47): Including file '../../avr8\words/less.asm' ../../avr8\dict/nrww.inc(48): Including file '../../avr8\words/greater.asm' ../../avr8\dict/nrww.inc(50): Including file '../../avr8\words/log2.asm' ../../avr8\dict/nrww.inc(51): Including file '../../avr8\words/minus.asm' ../../avr8\dict/nrww.inc(52): Including file '../../avr8\words/plus.asm' ../../avr8\dict/nrww.inc(53): Including file '../../avr8\words/mstar.asm' ../../avr8\dict/nrww.inc(54): Including file '../../avr8\words/umslashmod.asm' ../../avr8\dict/nrww.inc(55): Including file '../../avr8\words/umstar.asm' ../../avr8\dict/nrww.inc(57): Including file '../../avr8\words/invert.asm' ../../avr8\dict/nrww.inc(58): Including file '../../avr8\words/2slash.asm' ../../avr8\dict/nrww.inc(59): Including file '../../avr8\words/2star.asm' ../../avr8\dict/nrww.inc(60): Including file '../../avr8\words/and.asm' ../../avr8\dict/nrww.inc(61): Including file '../../avr8\words/or.asm' ../../avr8\dict/nrww.inc(62): Including file '../../avr8\words/xor.asm' ../../avr8\dict/nrww.inc(64): Including file '../../avr8\words/1plus.asm' ../../avr8\dict/nrww.inc(65): Including file '../../avr8\words/1minus.asm' ../../avr8\dict/nrww.inc(66): Including file '../../common\words/q-negate.asm' ../../avr8\dict/nrww.inc(67): Including file '../../avr8\words/lshift.asm' ../../avr8\dict/nrww.inc(68): Including file '../../avr8\words/rshift.asm' ../../avr8\dict/nrww.inc(69): Including file '../../avr8\words/plusstore.asm' ../../avr8\dict/nrww.inc(71): Including file '../../avr8\words/rpfetch.asm' ../../avr8\dict/nrww.inc(72): Including file '../../avr8\words/rpstore.asm' ../../avr8\dict/nrww.inc(73): Including file '../../avr8\words/spfetch.asm' ../../avr8\dict/nrww.inc(74): Including file '../../avr8\words/spstore.asm' ../../avr8\dict/nrww.inc(76): Including file '../../avr8\words/dodo.asm' ../../avr8\dict/nrww.inc(77): Including file '../../avr8\words/i.asm' ../../avr8\dict/nrww.inc(78): Including file '../../avr8\words/doplusloop.asm' ../../avr8\dict/nrww.inc(79): Including file '../../avr8\words/doloop.asm' ../../avr8\dict/nrww.inc(80): Including file '../../avr8\words/unloop.asm' ../../avr8\dict/nrww.inc(84): Including file '../../avr8\words/cmove_g.asm' ../../avr8\dict/nrww.inc(85): Including file '../../avr8\words/byteswap.asm' ../../avr8\dict/nrww.inc(86): Including file '../../avr8\words/up.asm' ../../avr8\dict/nrww.inc(87): Including file '../../avr8\words/1ms.asm' ../../avr8\dict/nrww.inc(88): Including file '../../avr8\words/2to_r.asm' ../../avr8\dict/nrww.inc(89): Including file '../../avr8\words/2r_from.asm' ../../avr8\dict/nrww.inc(91): Including file '../../avr8\words/store-e.asm' ../../avr8\dict/nrww.inc(92): Including file '../../avr8\words/fetch-e.asm' ../../avr8\dict/nrww.inc(93): Including file '../../avr8\words/store-i.asm' ../../avr8\dict/nrww.inc(97): Including file '../../avr8\words/store-i_nrww.asm' ../../avr8\dict/nrww.inc(99): Including file '../../avr8\words/fetch-i.asm' ../../avr8\dict/nrww.inc(104): Including file '../../avr8\dict/core_4k.inc' ../../avr8\dict/core_4k.inc(3): Including file '../../avr8\words/n_to_r.asm' ../../avr8\dict/core_4k.inc(4): Including file '../../avr8\words/n_r_from.asm' ../../avr8\dict/core_4k.inc(5): Including file '../../avr8\words/d-2star.asm' ../../avr8\dict/core_4k.inc(6): Including file '../../avr8\words/d-2slash.asm' ../../avr8\dict/core_4k.inc(7): Including file '../../avr8\words/d-plus.asm' ../../avr8\dict/core_4k.inc(8): Including file '../../avr8\words/d-minus.asm' ../../avr8\dict/core_4k.inc(9): Including file '../../avr8\words/d-invert.asm' ../../avr8\dict/core_4k.inc(10): Including file '../../avr8\words/slashmod.asm' ../../avr8\dict/core_4k.inc(11): Including file '../../common\words/abs.asm' ../../avr8\dict/core_4k.inc(12): Including file '../../common\words/pick.asm' ../../avr8\dict/core_4k.inc(13): Including file '../../avr8\words/cellplus.asm' ../../avr8\dict/core_4k.inc(14): Including file '../../avr8\dict/interrupt.inc' ../../avr8\dict/interrupt.inc(8): Including file '../../avr8\words/int-on.asm' ../../avr8\dict/interrupt.inc(9): Including file '../../avr8\words/int-off.asm' ../../avr8\dict/interrupt.inc(10): Including file '../../avr8\words/int-store.asm' ../../avr8\dict/interrupt.inc(11): Including file '../../avr8\words/int-fetch.asm' ../../avr8\dict/interrupt.inc(12): Including file '../../avr8\words/int-trap.asm' ../../avr8\dict/interrupt.inc(14): Including file '../../avr8\words/isr-exec.asm' ../../avr8\dict/interrupt.inc(15): Including file '../../avr8\words/isr-end.asm' ../../avr8\dict/core_4k.inc(17): Including file '../../common\words/prompt-ok.asm' ../../avr8\dict/core_4k.inc(18): Including file '../../common\words/prompt-ready.asm' ../../avr8\dict/core_4k.inc(19): Including file '../../common\words/prompt-error.asm' ../../avr8\dict/core_4k.inc(21): Including file '../../common\words/quit.asm' ../../avr8\dict/core_4k.inc(22): Including file '../../avr8\words/pause.asm' ../../avr8\dict/core_4k.inc(23): Including file '../../avr8\words/cold.asm' ../../avr8\dict/core_4k.inc(24): Including file '../../common\words/warm.asm' ../../avr8\dict/core_4k.inc(26): Including file '../../common\words/handler.asm' ../../avr8\dict/core_4k.inc(27): Including file '../../common\words/catch.asm' ../../avr8\dict/core_4k.inc(28): Including file '../../common\words/throw.asm' ../../avr8\dict/core_4k.inc(31): Including file '../../avr8\words/edefer-fetch.asm' ../../avr8\dict/core_4k.inc(32): Including file '../../avr8\words/edefer-store.asm' ../../avr8\dict/core_4k.inc(33): Including file '../../common\words/rdefer-fetch.asm' ../../avr8\dict/core_4k.inc(34): Including file '../../common\words/rdefer-store.asm' ../../avr8\dict/core_4k.inc(35): Including file '../../common\words/udefer-fetch.asm' ../../avr8\dict/core_4k.inc(36): Including file '../../common\words/udefer-store.asm' ../../avr8\dict/core_4k.inc(37): Including file '../../common\words/defer-store.asm' ../../avr8\dict/core_4k.inc(38): Including file '../../common\words/defer-fetch.asm' ../../avr8\dict/core_4k.inc(39): Including file '../../avr8\words/do-defer.asm' ../../avr8\dict/core_4k.inc(41): Including file '../../common\words/u-dot.asm' ../../avr8\dict/core_4k.inc(42): Including file '../../common\words/u-dot-r.asm' ../../avr8\dict/core_4k.inc(45): Including file '../../avr8\words/uslashmod.asm' ../../avr8\dict/core_4k.inc(46): Including file '../../avr8\words/negate.asm' ../../avr8\dict/core_4k.inc(47): Including file '../../common\words/slash.asm' ../../avr8\dict/core_4k.inc(48): Including file '../../common\words/mod.asm' ../../avr8\dict/core_4k.inc(50): Including file '../../common\words/min.asm' ../../avr8\dict/core_4k.inc(51): Including file '../../common\words/max.asm' ../../avr8\dict/core_4k.inc(52): Including file '../../common\words/within.asm' ../../avr8\dict/core_4k.inc(54): Including file '../../common\words/show-wordlist.asm' ../../avr8\dict/core_4k.inc(55): Including file '../../common\words/words.asm' ../../avr8\dict/core_4k.inc(57): Including file '../../common\words/dot-quote.asm' ../../avr8\dict/core_4k.inc(58): Including file '../../common\words/squote.asm' ../../avr8\dict/core_4k.inc(59): Including file '../../avr8\words/fill.asm' ../../avr8\dict/core_4k.inc(61): Including file '../../common\words/f_cpu.asm' ../../avr8\dict/core_4k.inc(62): Including file '../../avr8\words/state.asm' ../../avr8\dict/core_4k.inc(63): Including file '../../common\words/base.asm' ../../avr8\dict/core_4k.inc(65): Including file '../../avr8\words/cells.asm' ../../avr8\dict/core_4k.inc(67): Including file '../../common\words/2dup.asm' ../../avr8\dict/core_4k.inc(68): Including file '../../common\words/2drop.asm' ../../avr8\dict/core_4k.inc(69): Including file '../../common\words/tuck.asm' ../../avr8\dict/core_4k.inc(71): Including file '../../common\words/to-in.asm' ../../avr8\dict/core_4k.inc(72): Including file '../../common\words/pad.asm' ../../avr8\dict/core_4k.inc(73): Including file '../../common\words/emit.asm' ../../avr8\dict/core_4k.inc(74): Including file '../../common\words/emitq.asm' ../../avr8\dict/core_4k.inc(75): Including file '../../common\words/key.asm' ../../avr8\dict/core_4k.inc(76): Including file '../../common\words/keyq.asm' ../../avr8\dict/core_4k.inc(78): Including file '../../avr8\words/dp.asm' ../../avr8\dict/core_4k.inc(79): Including file '../../avr8\words/ehere.asm' ../../avr8\dict/core_4k.inc(80): Including file '../../avr8\words/here.asm' ../../avr8\dict/core_4k.inc(81): Including file '../../avr8\words/allot.asm' ../../avr8\dict/core_4k.inc(83): Including file '../../common\words/bin.asm' ../../avr8\dict/core_4k.inc(84): Including file '../../common\words/decimal.asm' ../../avr8\dict/core_4k.inc(85): Including file '../../common\words/hex.asm' ../../avr8\dict/core_4k.inc(86): Including file '../../common\words/bl.asm' ../../avr8\dict/core_4k.inc(88): Including file '../../avr8\words/turnkey.asm' ../../avr8\dict/core_4k.inc(89): Including file '../../common\words/to-upper.asm' ../../avr8\dict/core_4k.inc(90): Including file '../../common\words/to-lower.asm' ../../avr8\dict/core_4k.inc(92): Including file '../../common\words/q-stack.asm' ../../avr8\dict/core_4k.inc(93): Including file '../../common\words/bounds.asm' ../../avr8\dict/core_4k.inc(94): Including file '../../common\words/cr.asm' ../../avr8\dict/core_4k.inc(95): Including file '../../common\words/space.asm' ../../avr8\dict/core_4k.inc(96): Including file '../../common\words/spaces.asm' ../../avr8\dict/core_4k.inc(97): Including file '../../common\words/s-to-d.asm' ../../avr8\dict/core_4k.inc(98): Including file '../../avr8\words/to-body.asm' ../../avr8\dict/nrww.inc(112): Including file '../../common\words/2literal.asm' ../../avr8\dict/nrww.inc(113): Including file '../../avr8\words/equal.asm' ../../avr8\dict/nrww.inc(114): Including file '../../common\words/num-constants.asm' ../../avr8\amforth.asm(25): Including file 'dict_appl_core.inc' ../../avr8\amforth.asm(36): Including file '../../avr8\amforth-eeprom.inc' ; file see ../template/template.asm. You may want to ; copy that file to this one and edit it afterwards. .include "preamble.inc" .include "macros.asm" .set DICT_COMPILER2 = 0 ; .set cpu_msp430 = 0 .set cpu_avr8 = 1 .include "user.inc" ; ; used by the multitasker .set USER_STATE = 0 .set USER_FOLLOWER = 2 ; stackpointer, used by mulitasker .set USER_RP = 4 .set USER_SP0 = 6 .set USER_SP = 8 ; excpection handling .set USER_HANDLER = 10 ; numeric IO .set USER_BASE = 12 ; character IO .set USER_EMIT = 14 .set USER_EMITQ = 16 .set USER_KEY = 18 .set USER_KEYQ = 20 .set USER_SOURCE = 22 .set USER_TO_IN = 24 .set USER_REFILL = 26 .set USER_P_OK = 28 .set USER_P_ERR = 30 .set USER_P_RDY = 32 .set SYSUSERSIZE = 34 ; .def zerol = r2 .def zeroh = r3 .def upl = r4 .def uph = r5 .def al = r6 .def ah = r7 .def bl = r8 .def bh = r9 ; internal .def mcu_boot = r10 .def isrflag = r11 .def temp4 = r14 .def temp5 = r15 .def temp0 = r16 .def temp1 = r17 .def temp2 = r18 .def temp3 = r19 .def temp6 = r20 .def temp7 = r21 .def tosl = r24 .def tosh = r25 .def wl = r22 .def wh = r23 .macro loadtos ld tosl, Y+ ld tosh, Y+ .endmacro .macro savetos st -Y, tosh st -Y, tosl .endmacro .macro in_ .if (@1 < $40) in @0,@1 .else lds @0,@1 .endif .endmacro .macro out_ .if (@0 < $40) out @0,@1 .else sts @0,@1 .endif .endmacro .macro sbi_ .if (@0 < $40) sbi @0,@1 .else in_ @2,@0 ori @2,exp2(@1) out_ @0,@2 .endif .endmacro .macro cbi_ .if (@0 < $40) cbi @0,@1 .else in_ @2,@0 andi @2,~(exp2(@1)) out_ @0,@2 .endif .endmacro .macro jmp_ ; a more flexible macro .ifdef @0 .if (@0-pc > 2040) || (pc-@0>2040) jmp @0 .else rjmp @0 .endif .else jmp @0 .endif .endmacro .macro call_ ; a more flexible macro .ifdef @0 .if (@0-pc > 2040) || (pc-@0>2040) call @0 .else rcall @0 .endif .else call @0 .endif .endmacro ; F_CPU ; µsec 16000000 14745600 8000000 1000000 ; 1 16 14,74 8 1 ; 10 160 147,45 80 10 ; 100 1600 1474,56 800 100 ; 1000 16000 14745,6 8000 1000 ; ; cycles = µsec * f_cpu / 1e6 ; n_loops=cycles/5 ; ; cycles already used will be subtracted from the delay ; the waittime resolution is 1 cycle (delay from exact to +1 cycle) ; the maximum delay at 20MHz (50ns/clock) is 38350ns ; waitcount register must specify an immediate register ; ; busy waits a specfied amount of microseconds .macro delay .set cycles = ( ( @0 * F_CPU ) / 1000000 ) .if (cycles > ( 256 * 255 * 4 + 2)) .error "MACRO delay - too many cycles to burn" .else .if (cycles > 6) .set loop_cycles = (cycles / 4) ldi zl,low(loop_cycles) ldi zh,high(loop_cycles) sbiw Z, 1 brne pc-1 .set cycles = (cycles - (loop_cycles * 4)) .endif .if (cycles > 0) .if (cycles & 4) rjmp pc+1 rjmp pc+1 .endif .if (cycles & 2) rjmp pc+1 .endif .if (cycles & 1) nop .endif .endif .endif .endmacro ; portability macros, they come from the msp430 branches .macro DEST .dw @0 .endm ; controller specific file selected via include ; directory definition when calling the assembler (-I) .include "device.asm" ; generated automatically, do not edit .list .equ ramstart = 256 .equ CELLSIZE = 2 .macro readflashcell lsl zl rol zh lpm @0, Z+ lpm @1, Z+ .endmacro .macro writeflashcell lsl zl rol zh .endmacro .set WANT_WATCHDOG = 0 .set WANT_PORTD = 0 .set WANT_SPI = 0 .set WANT_USART1 = 0 .set WANT_BOOT_LOAD = 0 .set WANT_EEPROM = 0 .set WANT_TIMER_COUNTER_0 = 0 .set WANT_TIMER_COUNTER_3 = 0 .set WANT_TIMER_COUNTER_1 = 0 .set WANT_JTAG = 0 .set WANT_EXTERNAL_INTERRUPT = 0 .set WANT_TIMER_COUNTER_4 = 0 .set WANT_PORTB = 0 .set WANT_PORTC = 0 .set WANT_PORTE = 0 .set WANT_PORTF = 0 .set WANT_AD_CONVERTER = 0 .set WANT_ANALOG_COMPARATOR = 0 .set WANT_CPU = 0 .set WANT_PLL = 0 .set WANT_USB_DEVICE = 0 .equ intvecsize = 2 ; please verify; flash size: 32768 bytes .equ pclen = 2 ; please verify .overlap .org 2 000002 d0fc rcall isr ; External Interrupt Request 0 .org 4 000004 d0fa rcall isr ; External Interrupt Request 1 .org 6 000006 d0f8 rcall isr ; External Interrupt Request 2 .org 8 000008 d0f6 rcall isr ; External Interrupt Request 3 .org 10 00000a d0f4 rcall isr ; Reserved1 .org 12 00000c d0f2 rcall isr ; Reserved2 .org 14 00000e d0f0 rcall isr ; External Interrupt Request 6 .org 16 000010 d0ee rcall isr ; Reserved3 .org 18 000012 d0ec rcall isr ; Pin Change Interrupt Request 0 .org 20 000014 d0ea rcall isr ; USB General Interrupt Request .org 22 000016 d0e8 rcall isr ; USB Endpoint/Pipe Interrupt Communication Request .org 24 000018 d0e6 rcall isr ; Watchdog Time-out Interrupt .org 26 00001a d0e4 rcall isr ; Reserved4 .org 28 00001c d0e2 rcall isr ; Reserved5 .org 30 00001e d0e0 rcall isr ; Reserved6 .org 32 000020 d0de rcall isr ; Timer/Counter1 Capture Event .org 34 000022 d0dc rcall isr ; Timer/Counter1 Compare Match A .org 36 000024 d0da rcall isr ; Timer/Counter1 Compare Match B .org 38 000026 d0d8 rcall isr ; Timer/Counter1 Compare Match C .org 40 000028 d0d6 rcall isr ; Timer/Counter1 Overflow .org 42 00002a d0d4 rcall isr ; Timer/Counter0 Compare Match A .org 44 00002c d0d2 rcall isr ; Timer/Counter0 Compare Match B .org 46 00002e d0d0 rcall isr ; Timer/Counter0 Overflow .org 48 000030 d0ce rcall isr ; SPI Serial Transfer Complete .org 50 000032 d0cc rcall isr ; USART1, Rx Complete .org 52 000034 d0ca rcall isr ; USART1 Data register Empty .org 54 000036 d0c8 rcall isr ; USART1, Tx Complete .org 56 000038 d0c6 rcall isr ; Analog Comparator .org 58 00003a d0c4 rcall isr ; ADC Conversion Complete .org 60 00003c d0c2 rcall isr ; EEPROM Ready .org 62 00003e d0c0 rcall isr ; Timer/Counter3 Capture Event .org 64 000040 d0be rcall isr ; Timer/Counter3 Compare Match A .org 66 000042 d0bc rcall isr ; Timer/Counter3 Compare Match B .org 68 000044 d0ba rcall isr ; Timer/Counter3 Compare Match C .org 70 000046 d0b8 rcall isr ; Timer/Counter3 Overflow .org 72 000048 d0b6 rcall isr ; 2-wire Serial Interface .org 74 00004a d0b4 rcall isr ; Store Program Memory Read .org 76 00004c d0b2 rcall isr ; Timer/Counter4 Compare Match A .org 78 00004e d0b0 rcall isr ; Timer/Counter4 Compare Match B .org 80 000050 d0ae rcall isr ; Timer/Counter4 Compare Match D .org 82 000052 d0ac rcall isr ; Timer/Counter4 Overflow .org 84 000054 d0aa rcall isr ; Timer/Counter4 Fault Protection Interrupt .equ INTVECTORS = 43 .nooverlap ; compatability layer (maybe empty) ; controller data area, environment query mcu-info mcu_info: mcu_ramsize: 000055 0a00 .dw 2560 mcu_eepromsize: 000056 0400 .dw 1024 mcu_maxdp: 000057 7000 .dw 28672 mcu_numints: 000058 002b .dw 43 mcu_name: 000059 000a .dw 10 00005a 5441 00005b 656d 00005c 6167 00005d 3233 00005e 3455 .db "ATmega32U4" .set codestart=pc ; some defaults, change them in your application master file ; see template.asm for an example ; enabling Interrupts, disabling them affects ; other settings as well. .set WANT_INTERRUPTS = 1 ; count the number of interrupts individually. ; requires a lot of RAM (one byte per interrupt) ; disabled by default. .set WANT_INTERRUPT_COUNTERS = 0 ; receiving is asynchronously, so an interrupt queue is useful. .set WANT_ISR_RX = 1 ; case insensitve dictionary lookup. .set WANT_IGNORECASE = 0 ; map all memories to one address space. Details in the ; technical guide .set WANT_UNIFIED = 0 ; terminal input buffer .set TIB_SIZE = 90 ; ANS94 needs at least 80 characters per line ; USER variables *in addition* to system ones .set APPUSERSIZE = 10 ; size of application specific user area in bytes ; addresses of various data segments .set rstackstart = RAMEND ; start address of return stack, grows downward .set stackstart = RAMEND - 80 ; start address of data stack, grows downward ; change only if you know what to you do .set NUMWORDLISTS = 8 ; number of word lists in the searh order, at least 8 .set NUMRECOGNIZERS = 4 ; total number of recognizers, two are always used. ; 10 per mille (1 per cent) is ok. .set BAUD = 38400 .set BAUD_MAXERROR = 10 ; Dictionary setup .set VE_HEAD = $0000 .set VE_ENVHEAD = $0000 ; letters the same. Set to 0 if you do not want it .set WANT_IGNORECASE = 1 ; cpu clock in hertz .equ F_CPU = 16000000 .include "drivers/usart_1.asm" .equ BAUDRATE_HIGH = UBRR1H .equ USART_C = UCSR1C .equ USART_B = UCSR1B .equ USART_A = UCSR1A .equ USART_DATA = UDR1 .equ URXCaddr = URXC1addr .equ UDREaddr = UDRE1addr .equ bm_USART_RXRD = 1 << RXC1 .equ bm_USART_TXRD = 1 << UDRE1 .equ bm_ENABLE_TX = 1 << TXEN1 .equ bm_ENABLE_RX = 1 << RXEN1 .equ bm_ENABLE_INT_RX = 1<rx-buf",0 000064 0000 .dw VE_HEAD .set VE_HEAD = VE_TO_RXBUF XT_TO_RXBUF: 000065 0066 .dw PFA_rx_tobuf PFA_rx_tobuf: 000066 2f08 mov temp0, tosl 000067 9110 0110 lds temp1, usart_rx_in 000069 e0e0 ldi zl, low(usart_rx_data) 00006a e0f1 ldi zh, high(usart_rx_data) 00006b 0fe1 add zl, temp1 00006c 1df3 adc zh, zeroh 00006d 8300 st Z, temp0 00006e 9513 inc temp1 00006f 701f andi temp1,usart_rx_mask 000070 9310 0110 sts usart_rx_in, temp1 000072 9189 000073 9199 loadtos 000074 940c 3804 jmp_ DO_NEXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; setup with ; ' isr-rx URXCaddr int! VE_ISR_RX: 000076 ff06 .dw $ff06 000077 7369 000078 2d72 000079 7872 .db "isr-rx" 00007a 005f .dw VE_HEAD .set VE_HEAD = VE_ISR_RX XT_ISR_RX: 00007b 3800 .dw DO_COLON usart_rx_isr: 00007c 383c .dw XT_DOLITERAL 00007d 00ce .dw usart_data 00007e 3897 .dw XT_CFETCH 00007f 38b0 .dw XT_DUP 000080 383c .dw XT_DOLITERAL 000081 0003 .dw 3 000082 3fde .dw XT_EQUAL 000083 3835 .dw XT_DOCONDBRANCH 000084 0086 .dw usart_rx_isr1 000085 3d37 .dw XT_COLD usart_rx_isr1: 000086 0065 .dw XT_TO_RXBUF 000087 381f .dw XT_EXIT ; ( -- ) Hardware Access ; R( --) ; initialize usart ;VE_USART_INIT_RXBUFFER: ; .dw $ff0x ; .db "+usart-buffer" ; .dw VE_HEAD ; .set VE_HEAD = VE_USART_INIT_RXBUFFER XT_USART_INIT_RX_BUFFER: 000088 3800 .dw DO_COLON PFA_USART_INIT_RX_BUFFER: ; ( -- ) 000089 383c 00008a 007b .dw XT_DOLITERAL, XT_ISR_RX 00008b 383c 00008c 0032 .dw XT_DOLITERAL, URXCaddr 00008d 3ca4 .dw XT_INTSTORE 00008e 383c .dw XT_DOLITERAL 00008f 0100 .dw usart_rx_data 000090 383c .dw XT_DOLITERAL 000091 0016 .dw usart_rx_size + 6 000092 3953 .dw XT_ZERO 000093 3e97 .dw XT_FILL 000094 381f .dw XT_EXIT ; ( -- c) ; MCU ; get 1 character from input queue, wait if needed using interrupt driver VE_RX_BUFFER: 000095 ff06 .dw $ff06 000096 7872 000097 622d 000098 6675 .db "rx-buf" 000099 0076 .dw VE_HEAD .set VE_HEAD = VE_RX_BUFFER XT_RX_BUFFER: 00009a 3800 .dw DO_COLON PFA_RX_BUFFER: 00009b 00b5 .dw XT_RXQ_BUFFER 00009c 3835 .dw XT_DOCONDBRANCH 00009d 009b .dw PFA_RX_BUFFER 00009e 383c .dw XT_DOLITERAL 00009f 0111 .dw usart_rx_out 0000a0 3897 .dw XT_CFETCH 0000a1 38b0 .dw XT_DUP 0000a2 383c .dw XT_DOLITERAL 0000a3 0100 .dw usart_rx_data 0000a4 399c .dw XT_PLUS 0000a5 3897 .dw XT_CFETCH 0000a6 38c3 .dw XT_SWAP 0000a7 3a2e .dw XT_1PLUS 0000a8 383c .dw XT_DOLITERAL 0000a9 000f .dw usart_rx_mask 0000aa 3a12 .dw XT_AND 0000ab 383c .dw XT_DOLITERAL 0000ac 0111 .dw usart_rx_out 0000ad 388c .dw XT_CSTORE 0000ae 381f .dw XT_EXIT ; ( -- f) ; MCU ; check if unread characters are in the input queue VE_RXQ_BUFFER: 0000af ff07 .dw $ff07 0000b0 7872 0000b1 2d3f 0000b2 7562 0000b3 0066 .db "rx?-buf",0 0000b4 0095 .dw VE_HEAD .set VE_HEAD = VE_RXQ_BUFFER XT_RXQ_BUFFER: 0000b5 3800 .dw DO_COLON PFA_RXQ_BUFFER: 0000b6 3d2f .dw XT_PAUSE 0000b7 383c .dw XT_DOLITERAL 0000b8 0111 .dw usart_rx_out 0000b9 3897 .dw XT_CFETCH 0000ba 383c .dw XT_DOLITERAL 0000bb 0110 .dw usart_rx_in 0000bc 3897 .dw XT_CFETCH 0000bd 3912 .dw XT_NOTEQUAL 0000be 381f .dw XT_EXIT ; .include "drivers/timer-usart-isr.asm" .set XT_RX = XT_RX_BUFFER .set XT_RXQ = XT_RXQ_BUFFER .set XT_USART_INIT_RX = XT_USART_INIT_RX_BUFFER .else .endif .include "words/usart-tx-poll.asm" ; MCU ; check availability and send one character to the terminal using register poll VE_TX_POLL: 0000bf ff07 .dw $ff07 0000c0 7874 0000c1 702d 0000c2 6c6f 0000c3 006c .db "tx-poll",0 0000c4 00af .dw VE_HEAD .set VE_HEAD = VE_TX_POLL XT_TX_POLL: 0000c5 3800 .dw DO_COLON PFA_TX_POLL: ; wait for data ready 0000c6 00d3 .dw XT_TXQ_POLL 0000c7 3835 .dw XT_DOCONDBRANCH 0000c8 00c6 .dw PFA_TX_POLL ; send to usart 0000c9 383c .dw XT_DOLITERAL 0000ca 00ce .dw USART_DATA 0000cb 388c .dw XT_CSTORE 0000cc 381f .dw XT_EXIT ; ( -- f) MCU ; MCU ; check if a character can be send using register poll VE_TXQ_POLL: 0000cd ff08 .dw $ff08 0000ce 7874 0000cf 2d3f 0000d0 6f70 0000d1 6c6c .db "tx?-poll" 0000d2 00bf .dw VE_HEAD .set VE_HEAD = VE_TXQ_POLL XT_TXQ_POLL: 0000d3 3800 .dw DO_COLON PFA_TXQ_POLL: 0000d4 3d2f .dw XT_PAUSE 0000d5 383c .dw XT_DOLITERAL 0000d6 00c8 .dw USART_A 0000d7 3897 .dw XT_CFETCH 0000d8 383c .dw XT_DOLITERAL 0000d9 0020 .dw bm_USART_TXRD 0000da 3a12 .dw XT_AND 0000db 381f .dw XT_EXIT .set XT_TX = XT_TX_POLL .set XT_TXQ = XT_TXQ_POLL .set XT_USART_INIT_TX = 0 .include "words/ubrr.asm" ; MCU ; returns usart UBRR settings VE_UBRR: 0000dc ff04 .dw $ff04 0000dd 6275 0000de 7272 .db "ubrr" 0000df 00cd .dw VE_HEAD .set VE_HEAD = VE_UBRR XT_UBRR: 0000e0 386e .dw PFA_DOVALUE1 PFA_UBRR: ; ( -- ) 0000e1 00ae .dw EE_UBRRVAL 0000e2 3d9f .dw XT_EDEFERFETCH 0000e3 3da9 .dw XT_EDEFERSTORE .include "words/usart.asm" ; MCU ; initialize usart VE_USART: 0000e4 ff06 .dw $ff06 0000e5 752b 0000e6 6173 0000e7 7472 .db "+usart" 0000e8 00dc .dw VE_HEAD .set VE_HEAD = VE_USART XT_USART: 0000e9 3800 .dw DO_COLON PFA_USART: ; ( -- ) 0000ea 383c .dw XT_DOLITERAL 0000eb 0098 .dw USART_B_VALUE 0000ec 383c .dw XT_DOLITERAL 0000ed 00c9 .dw USART_B 0000ee 388c .dw XT_CSTORE 0000ef 383c .dw XT_DOLITERAL 0000f0 0006 .dw USART_C_VALUE 0000f1 383c .dw XT_DOLITERAL 0000f2 00ca .dw USART_C | bm_USARTC_en 0000f3 388c .dw XT_CSTORE 0000f4 00e0 .dw XT_UBRR 0000f5 38b0 .dw XT_DUP 0000f6 3af8 .dw XT_BYTESWAP 0000f7 383c .dw XT_DOLITERAL 0000f8 00cd .dw BAUDRATE_HIGH 0000f9 388c .dw XT_CSTORE 0000fa 383c .dw XT_DOLITERAL 0000fb 00cc .dw BAUDRATE_LOW 0000fc 388c .dw XT_CSTORE .if XT_USART_INIT_RX!=0 0000fd 0088 .dw XT_USART_INIT_RX .endif .if XT_USART_INIT_TX!=0 .endif 0000fe 381f .dw XT_EXIT .include "amforth.asm" ;;;; ;;;; GPL V2 (only) .set AMFORTH_NRWW_SIZE=(FLASHEND-AMFORTH_RO_SEG)*2 .set corepc = pc .org $0000 000000 940c 3d38 jmp_ PFA_COLD .org corepc .include "drivers/generic-isr.asm" .eseg 000000 intvec: .byte INTVECTORS * CELLSIZE .dseg 000112 intcnt: .byte INTVECTORS .cseg ; interrupt routine gets called (again) by rcall! This gives the ; address of the int-vector on the stack. isr: 0000ff 920a st -Y, r0 000100 b60f in r0, SREG 000101 920a st -Y, r0 .if (pclen==3) .endif 000102 900f pop r0 000103 900f pop r0 ; = intnum * intvectorsize + 1 (address following the rcall) 000104 940a dec r0 .if intvecsize == 1 ; .endif 000105 2cb0 mov isrflag, r0 000106 93ff push zh 000107 93ef push zl 000108 e1e2 ldi zl, low(intcnt) 000109 e0f1 ldi zh, high(intcnt) 00010a 9406 lsr r0 ; we use byte addresses in the counter array, not words 00010b 0de0 add zl, r0 00010c 1df3 adc zh, zeroh 00010d 8000 ld r0, Z 00010e 9403 inc r0 00010f 8200 st Z, r0 000110 91ef pop zl 000111 91ff pop zh 000112 9009 ld r0, Y+ 000113 be0f out SREG, r0 000114 9009 ld r0, Y+ 000115 9508 ret ; returns the interrupt, the rcall stack frame is removed! ; no reti here, see words/isr-end.asm ; lower part of the dictionary .include "dict/rww.inc" ; Arithmetics ; add a number to a double cell VE_MPLUS: 000116 ff02 .dw $ff02 000117 2b6d .db "m+" 000118 00e4 .dw VE_HEAD .set VE_HEAD = VE_MPLUS XT_MPLUS: 000119 3800 .dw DO_COLON PFA_MPLUS: 00011a 3fc6 .dw XT_S2D 00011b 3c14 .dw XT_DPLUS 00011c 381f .dw XT_EXIT .include "words/ud-star.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDSTAR: 00011d ff03 .dw $ff03 00011e 6475 ../../common\words/ud-star.asm(9): warning: .cseg .db misalignment - padding zero byte 00011f 002a .db "ud*" 000120 0116 .dw VE_HEAD .set VE_HEAD = VE_UDSTAR XT_UDSTAR: 000121 3800 .dw DO_COLON PFA_UDSTAR: .endif ;Z UD* ud1 d2 -- ud3 32*16->32 multiply ; XT_DUP >R UM* DROP XT_SWAP R> UM* ROT + ; 000122 38b0 000123 38fe 000124 39df 000125 38d8 .DW XT_DUP,XT_TO_R,XT_UMSTAR,XT_DROP 000126 38c3 000127 38f5 000128 39df 000129 38e0 00012a 399c 00012b 381f .DW XT_SWAP,XT_R_FROM,XT_UMSTAR,XT_ROT,XT_PLUS,XT_EXIT .include "words/umax.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UMAX: 00012c ff04 .dw $ff04 00012d 6d75 00012e 7861 .db "umax" 00012f 011d .dw VE_HEAD .set VE_HEAD = VE_UMAX XT_UMAX: 000130 3800 .dw DO_COLON PFA_UMAX: .endif 000131 3ec8 000132 395b .DW XT_2DUP,XT_ULESS 000133 3835 .dw XT_DOCONDBRANCH 000134 0136 DEST(UMAX1) 000135 38c3 .DW XT_SWAP 000136 38d8 UMAX1: .DW XT_DROP 000137 381f .dw XT_EXIT .include "words/umin.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UMIN: 000138 ff04 .dw $ff04 000139 6d75 00013a 6e69 .db "umin" 00013b 012c .dw VE_HEAD .set VE_HEAD = VE_UMIN XT_UMIN: 00013c 3800 .dw DO_COLON PFA_UMIN: .endif 00013d 3ec8 00013e 3966 .DW XT_2DUP,XT_UGREATER 00013f 3835 .dw XT_DOCONDBRANCH 000140 0142 DEST(UMIN1) 000141 38c3 .DW XT_SWAP 000142 38d8 UMIN1: .DW XT_DROP 000143 381f .dw XT_EXIT .include "words/immediate-q.asm" ; Tools ; return +1 if immediate, -1 otherwise, flag from name>flags ;VE_IMMEDIATEQ: ; .dw $ff06 ; .db "immediate?" ; .dw VE_HEAD ; .set VE_HEAD = VE_IMMEDIATEQ XT_IMMEDIATEQ: 000144 3800 .dw DO_COLON PFA_IMMEDIATEQ: 000145 383c .dw XT_DOLITERAL 000146 8000 .dw $8000 000147 3a12 .dw XT_AND 000148 3919 .dw XT_ZEROEQUAL 000149 3835 .dw XT_DOCONDBRANCH 00014a 014d DEST(IMMEDIATEQ1) 00014b 3fe5 .dw XT_ONE 00014c 381f .dw XT_EXIT IMMEDIATEQ1: ; not immediate 00014d 394a .dw XT_TRUE 00014e 381f .dw XT_EXIT .include "words/name2flags.asm" ; Tools ; get the flags from a name token VE_NAME2FLAGS: 00014f ff0a .dw $ff0a 000150 616e 000151 656d 000152 663e 000153 616c 000154 7367 .db "name>flags" 000155 0138 .dw VE_HEAD .set VE_HEAD = VE_NAME2FLAGS XT_NAME2FLAGS: 000156 3800 .dw DO_COLON PFA_NAME2FLAGS: 000157 3bca .dw XT_FETCHI ; skip to link field 000158 383c .dw XT_DOLITERAL 000159 ff00 .dw $ff00 00015a 3a12 .dw XT_AND 00015b 381f .dw XT_EXIT .if AMFORTH_NRWW_SIZE > 8000 .elif AMFORTH_NRWW_SIZE > 4000 .include "dict/appl_4k.inc" ; Tools ; print the version string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DOT_VER: 00015c ff03 .dw $ff03 00015d 6576 ../../common\words/ver.asm(12): warning: .cseg .db misalignment - padding zero byte 00015e 0072 .db "ver" 00015f 014f .dw VE_HEAD .set VE_HEAD = VE_DOT_VER XT_DOT_VER: 000160 3800 .dw DO_COLON PFA_DOT_VER: .endif 000161 02c1 .dw XT_ENV_FORTHNAME 000162 03ea .dw XT_ITYPE 000163 3fad .dw XT_SPACE 000164 3ebc .dw XT_BASE 000165 3878 .dw XT_FETCH 000166 02cf .dw XT_ENV_FORTHVERSION 000167 3f40 .dw XT_DECIMAL 000168 3fc6 .dw XT_S2D 000169 0308 .dw XT_L_SHARP 00016a 0310 .dw XT_SHARP 00016b 383c .dw XT_DOLITERAL 00016c 002e .dw '.' 00016d 02f9 .dw XT_HOLD 00016e 0326 .dw XT_SHARP_S 00016f 0331 .dw XT_SHARP_G 000170 0420 .dw XT_TYPE 000171 3ebc .dw XT_BASE 000172 3880 .dw XT_STORE 000173 3fad .dw XT_SPACE 000174 02d7 .dw XT_ENV_CPU 000175 03ea .dw XT_ITYPE 000176 381f .dw XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/noop.asm" ; Tools ; do nothing .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_NOOP: 000177 ff04 .dw $ff04 000178 6f6e 000179 706f .db "noop" 00017a 015c .dw VE_HEAD .set VE_HEAD = VE_NOOP XT_NOOP: 00017b 3800 .dw DO_COLON PFA_NOOP: .endif 00017c 381f .DW XT_EXIT .include "words/unused.asm" ; Tools ; Amount of available RAM (incl. PAD) VE_UNUSED: 00017d ff06 .dw $ff06 00017e 6e75 00017f 7375 000180 6465 .db "unused" 000181 0177 .dw VE_HEAD .set VE_HEAD = VE_UNUSED XT_UNUSED: 000182 3800 .dw DO_COLON PFA_UNUSED: 000183 3a8c .dw XT_SP_FETCH 000184 3f22 .dw XT_HERE 000185 3992 .dw XT_MINUS 000186 381f .dw XT_EXIT .include "words/to.asm" ; Tools ; store the TOS to the named value (eeprom cell) .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TO: 000187 0002 .dw $0002 000188 6f74 .db "to" 000189 017d .dw VE_HEAD .set VE_HEAD = VE_TO XT_TO: 00018a 3800 .dw DO_COLON PFA_TO: .endif 00018b 042f .dw XT_TICK 00018c 3fcf .dw XT_TO_BODY 00018d 3eb6 .dw XT_STATE 00018e 3878 .dw XT_FETCH 00018f 3835 .dw XT_DOCONDBRANCH 000190 019b DEST(PFA_TO1) 000191 0743 .dw XT_COMPILE 000192 0195 .dw XT_DOTO 000193 074e .dw XT_COMMA 000194 381f .dw XT_EXIT ; ( n -- ) (R: IP -- IP+1) ; Tools ; runtime portion of to ;VE_DOTO: ; .dw $ff04 ; .db "(to)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOTO .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_DOTO: 000195 3800 .dw DO_COLON PFA_DOTO: .endif 000196 38f5 .dw XT_R_FROM 000197 38b0 .dw XT_DUP 000198 01a7 .dw XT_ICELLPLUS 000199 38fe .dw XT_TO_R 00019a 3bca .dw XT_FETCHI PFA_TO1: 00019b 38b0 .dw XT_DUP 00019c 01a7 .dw XT_ICELLPLUS 00019d 01a7 .dw XT_ICELLPLUS 00019e 3bca .dw XT_FETCHI 00019f 3829 .dw XT_EXECUTE 0001a0 381f .dw XT_EXIT .include "words/i-cellplus.asm" ; Compiler ; skip to the next cell in flash VE_ICELLPLUS: 0001a1 ff07 .dw $FF07 0001a2 2d69 0001a3 6563 0001a4 6c6c 0001a5 002b .db "i-cell+",0 0001a6 0187 .dw VE_HEAD .set VE_HEAD = VE_ICELLPLUS XT_ICELLPLUS: 0001a7 3800 .dw DO_COLON PFA_ICELLPLUS: 0001a8 3a2e .dw XT_1PLUS 0001a9 381f .dw XT_EXIT .include "words/icompare.asm" ; Tools ; compares string in RAM with string in flash. f is zero if equal like COMPARE VE_ICOMPARE: 0001aa ff08 .dw $ff08 0001ab 6369 0001ac 6d6f 0001ad 6170 0001ae 6572 .db "icompare" 0001af 01a1 .dw VE_HEAD .set VE_HEAD = VE_ICOMPARE XT_ICOMPARE: 0001b0 3800 .dw DO_COLON PFA_ICOMPARE: 0001b1 38fe .dw XT_TO_R ; ( -- r-addr r-len f-addr) 0001b2 38ce .dw XT_OVER ; ( -- r-addr r-len f-addr r-len) 0001b3 38f5 .dw XT_R_FROM ; ( -- r-addr r-len f-addr r-len f-len ) 0001b4 3912 .dw XT_NOTEQUAL ; ( -- r-addr r-len f-addr flag ) 0001b5 3835 .dw XT_DOCONDBRANCH 0001b6 01bb .dw PFA_ICOMPARE_SAMELEN 0001b7 3ed1 .dw XT_2DROP 0001b8 38d8 .dw XT_DROP 0001b9 394a .dw XT_TRUE 0001ba 381f .dw XT_EXIT PFA_ICOMPARE_SAMELEN: 0001bb 38c3 .dw XT_SWAP ; ( -- r-addr f-addr len ) 0001bc 3953 .dw XT_ZERO 0001bd 080d .dw XT_QDOCHECK 0001be 3835 .dw XT_DOCONDBRANCH 0001bf 01e0 .dw PFA_ICOMPARE_DONE 0001c0 3a9a .dw XT_DODO PFA_ICOMPARE_LOOP: ; ( r-addr f-addr --) 0001c1 38ce .dw XT_OVER 0001c2 3878 .dw XT_FETCH .if WANT_IGNORECASE == 1 0001c3 01e3 .dw XT_ICOMPARE_LC .endif 0001c4 38ce .dw XT_OVER 0001c5 3bca .dw XT_FETCHI ; ( -- r-addr f-addr r-cc f- cc) .if WANT_IGNORECASE == 1 0001c6 01e3 .dw XT_ICOMPARE_LC .endif ; flash strings are zero-padded at the last cell ; that means: if the flash cell is less $0100, than mask the ; high byte in the ram cell 0001c7 38b0 .dw XT_DUP ;.dw XT_BYTESWAP 0001c8 383c .dw XT_DOLITERAL 0001c9 0100 .dw $100 0001ca 395b .dw XT_ULESS 0001cb 3835 .dw XT_DOCONDBRANCH 0001cc 01d1 .dw PFA_ICOMPARE_LASTCELL 0001cd 38c3 .dw XT_SWAP 0001ce 383c .dw XT_DOLITERAL 0001cf 00ff .dw $00FF 0001d0 3a12 .dw XT_AND ; the final swap can be omitted PFA_ICOMPARE_LASTCELL: 0001d1 3912 .dw XT_NOTEQUAL 0001d2 3835 .dw XT_DOCONDBRANCH 0001d3 01d8 .dw PFA_ICOMPARE_NEXTLOOP 0001d4 3ed1 .dw XT_2DROP 0001d5 394a .dw XT_TRUE 0001d6 3ad3 .dw XT_UNLOOP 0001d7 381f .dw XT_EXIT PFA_ICOMPARE_NEXTLOOP: 0001d8 3a2e .dw XT_1PLUS 0001d9 38c3 .dw XT_SWAP 0001da 3c8f .dw XT_CELLPLUS 0001db 38c3 .dw XT_SWAP 0001dc 383c .dw XT_DOLITERAL 0001dd 0002 .dw 2 0001de 3ab9 .dw XT_DOPLUSLOOP 0001df 01c1 .dw PFA_ICOMPARE_LOOP PFA_ICOMPARE_DONE: 0001e0 3ed1 .dw XT_2DROP 0001e1 3953 .dw XT_ZERO 0001e2 381f .dw XT_EXIT .if WANT_IGNORECASE == 1 ; ( cc1 cc2 -- f) ; Tools ; compares two packed characters ;VE_ICOMPARELC: ; .dw $ff08 ; .db "icompare-lower" ; .dw VE_HEAD ; .set VE_HEAD = VE_ICOMPARELC XT_ICOMPARE_LC: 0001e3 3800 .dw DO_COLON PFA_ICOMPARE_LC: 0001e4 38b0 .dw XT_DUP 0001e5 383c .dw XT_DOLITERAL 0001e6 00ff .dw $00ff 0001e7 3a12 .dw XT_AND 0001e8 3f78 .dw XT_TOLOWER 0001e9 38c3 .dw XT_SWAP 0001ea 3af8 .dw XT_BYTESWAP 0001eb 383c .dw XT_DOLITERAL 0001ec 00ff .dw $00ff 0001ed 3a12 .dw XT_AND 0001ee 3f78 .dw XT_TOLOWER 0001ef 3af8 .dw XT_BYTESWAP 0001f0 3a1b .dw XT_OR 0001f1 381f .dw XT_EXIT .endif .include "words/star.asm" ; Arithmetics ; multiply routine .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_STAR: 0001f2 ff01 .dw $ff01 0001f3 002a .db "*",0 0001f4 01aa .dw VE_HEAD .set VE_HEAD = VE_STAR XT_STAR: 0001f5 3800 .dw DO_COLON PFA_STAR: .endif 0001f6 39a5 .dw XT_MSTAR 0001f7 38d8 .dw XT_DROP 0001f8 381f .dw XT_EXIT .include "words/j.asm" ; Compiler ; loop counter of outer loop VE_J: 0001f9 ff01 .dw $FF01 0001fa 006a .db "j",0 0001fb 01f2 .dw VE_HEAD .set VE_HEAD = VE_J XT_J: 0001fc 3800 .dw DO_COLON PFA_J: 0001fd 3a75 .dw XT_RP_FETCH 0001fe 383c .dw XT_DOLITERAL 0001ff 0007 .dw 7 000200 399c .dw XT_PLUS 000201 3878 .dw XT_FETCH 000202 3a75 .dw XT_RP_FETCH 000203 383c .dw XT_DOLITERAL 000204 0009 .dw 9 000205 399c .dw XT_PLUS 000206 3878 .dw XT_FETCH 000207 399c .dw XT_PLUS 000208 381f .dw XT_EXIT .include "words/dabs.asm" ; Arithmetics ; double cell absolute value VE_DABS: 000209 ff04 .dw $ff04 00020a 6164 00020b 7362 .db "dabs" 00020c 01f9 .dw VE_HEAD .set VE_HEAD = VE_DABS XT_DABS: 00020d 3800 .dw DO_COLON PFA_DABS: 00020e 38b0 .dw XT_DUP 00020f 3920 .dw XT_ZEROLESS 000210 3835 .dw XT_DOCONDBRANCH 000211 0213 .dw PFA_DABS1 000212 021a .dw XT_DNEGATE PFA_DABS1: 000213 381f .dw XT_EXIT ; : dabs ( ud1 -- +d2 ) dup 0< if dnegate then ; .include "words/dnegate.asm" ; Arithmetics ; double cell negation VE_DNEGATE: 000214 ff07 .dw $ff07 000215 6e64 000216 6765 000217 7461 000218 0065 .db "dnegate",0 000219 0209 .dw VE_HEAD .set VE_HEAD = VE_DNEGATE XT_DNEGATE: 00021a 3800 .dw DO_COLON PFA_DNEGATE: 00021b 3c3a .dw XT_DINVERT 00021c 3fe5 .dw XT_ONE 00021d 3953 .dw XT_ZERO 00021e 3c14 .dw XT_DPLUS 00021f 381f .dw XT_EXIT ; : dnegate ( ud1 -- ud2 ) dinvert 1. d+ ; .include "words/cmove.asm" ; Memory ; copy data in RAM, from lower to higher addresses VE_CMOVE: 000220 ff05 .dw $ff05 000221 6d63 000222 766f 000223 0065 .db "cmove",0 000224 0214 .dw VE_HEAD .set VE_HEAD = VE_CMOVE XT_CMOVE: 000225 0226 .dw PFA_CMOVE PFA_CMOVE: 000226 93bf push xh 000227 93af push xl 000228 91e9 ld zl, Y+ 000229 91f9 ld zh, Y+ ; addr-to 00022a 91a9 ld xl, Y+ 00022b 91b9 ld xh, Y+ ; addr-from 00022c 2f09 mov temp0, tosh 00022d 2b08 or temp0, tosl 00022e f021 brbs 1, PFA_CMOVE1 PFA_CMOVE2: 00022f 911d ld temp1, X+ 000230 9311 st Z+, temp1 000231 9701 sbiw tosl, 1 000232 f7e1 brbc 1, PFA_CMOVE2 PFA_CMOVE1: 000233 91af pop xl 000234 91bf pop xh 000235 9189 000236 9199 loadtos 000237 940c 3804 jmp_ DO_NEXT .include "words/2swap.asm" ; Stack ; Exchange the two top cell pairs .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_2SWAP: 000239 ff05 .dw $ff05 00023a 7332 00023b 6177 00023c 0070 .db "2swap",0 00023d 0220 .dw VE_HEAD .set VE_HEAD = VE_2SWAP XT_2SWAP: 00023e 3800 .dw DO_COLON PFA_2SWAP: .endif 00023f 38e0 .dw XT_ROT 000240 38fe .dw XT_TO_R 000241 38e0 .dw XT_ROT 000242 38f5 .dw XT_R_FROM 000243 381f .dw XT_EXIT .include "words/tib.asm" ; System ; refills the input buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_REFILLTIB: 000244 ff0a .dw $ff0a 000245 6572 000246 6966 000247 6c6c 000248 742d 000249 6269 .db "refill-tib" 00024a 0239 .dw VE_HEAD .set VE_HEAD = VE_REFILLTIB XT_REFILLTIB: 00024b 3800 .dw DO_COLON PFA_REFILLTIB: .endif 00024c 0267 .dw XT_TIB 00024d 383c .dw XT_DOLITERAL 00024e 005a .dw TIB_SIZE 00024f 047f .dw XT_ACCEPT 000250 026d .dw XT_NUMBERTIB 000251 3880 .dw XT_STORE 000252 3953 .dw XT_ZERO 000253 3ee1 .dw XT_TO_IN 000254 3880 .dw XT_STORE 000255 394a .dw XT_TRUE ; -1 000256 381f .dw XT_EXIT ; ( -- addr n ) ; System ; address and current length of the input buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SOURCETIB: 000257 ff0a .dw $FF0A 000258 6f73 000259 7275 00025a 6563 00025b 742d 00025c 6269 .db "source-tib" 00025d 0244 .dw VE_HEAD .set VE_HEAD = VE_SOURCETIB XT_SOURCETIB: 00025e 3800 .dw DO_COLON PFA_SOURCETIB: .endif 00025f 0267 .dw XT_TIB 000260 026d .dw XT_NUMBERTIB 000261 3878 .dw XT_FETCH 000262 381f .dw XT_EXIT ; ( -- addr ) ; System Variable ; terminal input buffer address .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TIB: 000263 ff03 .dw $ff03 000264 6974 000265 0062 .db "tib",0 000266 0257 .dw VE_HEAD .set VE_HEAD = VE_TIB XT_TIB: 000267 3847 .dw PFA_DOVARIABLE PFA_TIB: 000268 013d .dw ram_tib .dseg 00013d ram_tib: .byte TIB_SIZE .cseg .endif ; ( -- addr ) ; System Variable ; variable holding the number of characters in TIB .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_NUMBERTIB: 000269 ff04 .dw $ff04 00026a 7423 00026b 6269 .db "#tib" 00026c 0263 .dw VE_HEAD .set VE_HEAD = VE_NUMBERTIB XT_NUMBERTIB: 00026d 3847 .dw PFA_DOVARIABLE PFA_NUMBERTIB: 00026e 0197 .dw ram_sharptib .dseg 000197 ram_sharptib: .byte 2 .cseg .endif .include "words/init-ram.asm" ; Tools ; copy len cells from eeprom to ram VE_EE2RAM: 00026f ff06 .dw $ff06 000270 6565 000271 723e 000272 6d61 .db "ee>ram" 000273 0269 .dw VE_HEAD .set VE_HEAD = VE_EE2RAM XT_EE2RAM: 000274 3800 .dw DO_COLON PFA_EE2RAM: ; ( -- ) 000275 3953 .dw XT_ZERO 000276 3a9a .dw XT_DODO PFA_EE2RAM_1: ; ( -- e-addr r-addr ) 000277 38ce .dw XT_OVER 000278 3b5e .dw XT_FETCHE 000279 38ce .dw XT_OVER 00027a 3880 .dw XT_STORE 00027b 3c8f .dw XT_CELLPLUS 00027c 38c3 .dw XT_SWAP 00027d 3c8f .dw XT_CELLPLUS 00027e 38c3 .dw XT_SWAP 00027f 3ac8 .dw XT_DOLOOP 000280 0277 .dw PFA_EE2RAM_1 PFA_EE2RAM_2: 000281 3ed1 .dw XT_2DROP 000282 381f .dw XT_EXIT ; ( -- ) ; Tools ; setup the default user area from eeprom VE_INIT_RAM: 000283 ff08 .dw $ff08 000284 6e69 000285 7469 000286 722d 000287 6d61 .db "init-ram" 000288 026f .dw VE_HEAD .set VE_HEAD = VE_INIT_RAM XT_INIT_RAM: 000289 3800 .dw DO_COLON PFA_INI_RAM: ; ( -- ) 00028a 383c .dw XT_DOLITERAL 00028b 008c .dw EE_INITUSER 00028c 3b01 .dw XT_UP_FETCH 00028d 383c .dw XT_DOLITERAL 00028e 0022 .dw SYSUSERSIZE 00028f 3a03 .dw XT_2SLASH 000290 0274 .dw XT_EE2RAM 000291 381f .dw XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/environment.asm" ; System Value ; word list identifier of the environmental search list VE_ENVIRONMENT: 000292 ff0b .dw $ff0b 000293 6e65 000294 6976 000295 6f72 000296 6d6e 000297 6e65 000298 0074 .db "environment",0 000299 0283 .dw VE_HEAD .set VE_HEAD = VE_ENVIRONMENT XT_ENVIRONMENT: 00029a 3847 .dw PFA_DOVARIABLE PFA_ENVIRONMENT: 00029b 0066 .dw CFG_ENVIRONMENT .include "words/env-wordlists.asm" ; Environment ; maximum number of wordlists in the dictionary search order VE_ENVWORDLISTS: 00029c ff09 .dw $ff09 00029d 6f77 00029e 6472 00029f 696c 0002a0 7473 0002a1 0073 .db "wordlists",0 0002a2 0000 .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENVWORDLISTS XT_ENVWORDLISTS: 0002a3 3800 .dw DO_COLON PFA_ENVWORDLISTS: 0002a4 383c .dw XT_DOLITERAL 0002a5 0008 .dw NUMWORDLISTS 0002a6 381f .dw XT_EXIT .include "words/env-slashpad.asm" ; Environment ; Size of the PAD buffer in bytes VE_ENVSLASHPAD: 0002a7 ff04 .dw $ff04 0002a8 702f 0002a9 6461 .db "/pad" 0002aa 029c .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENVSLASHPAD XT_ENVSLASHPAD: 0002ab 3800 .dw DO_COLON PFA_ENVSLASHPAD: 0002ac 3a8c .dw XT_SP_FETCH 0002ad 3ee7 .dw XT_PAD 0002ae 3992 .dw XT_MINUS 0002af 381f .dw XT_EXIT .include "words/env-slashhold.asm" ; Environment ; size of the pictured numeric output buffer in bytes .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENVSLASHHOLD: 0002b0 ff05 .dw $ff05 0002b1 682f 0002b2 6c6f 0002b3 0064 .db "/hold",0 0002b4 02a7 .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENVSLASHHOLD XT_ENVSLASHHOLD: 0002b5 3800 .dw DO_COLON PFA_ENVSLASHHOLD: .endif 0002b6 3ee7 .dw XT_PAD 0002b7 3f22 .dw XT_HERE 0002b8 3992 .dw XT_MINUS 0002b9 381f .dw XT_EXIT .include "words/env-forthname.asm" ; Environment ; flash address of the amforth name string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENV_FORTHNAME: 0002ba ff0a .dw $ff0a 0002bb 6f66 0002bc 7472 0002bd 2d68 0002be 616e 0002bf 656d .db "forth-name" 0002c0 02b0 .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENV_FORTHNAME XT_ENV_FORTHNAME: 0002c1 3800 .dw DO_COLON PFA_EN_FORTHNAME: 0002c2 03b7 .dw XT_DOSLITERAL 0002c3 0007 .dw 7 .endif 0002c4 6d61 0002c5 6f66 0002c6 7472 ../../common\words/env-forthname.asm(22): warning: .cseg .db misalignment - padding zero byte 0002c7 0068 .db "amforth" .if cpu_msp430==1 .endif 0002c8 381f .dw XT_EXIT .include "words/env-forthversion.asm" ; Environment ; version number of amforth .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENV_FORTHVERSION: 0002c9 ff07 .dw $ff07 0002ca 6576 0002cb 7372 0002cc 6f69 0002cd 006e .db "version",0 0002ce 02ba .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENV_FORTHVERSION XT_ENV_FORTHVERSION: 0002cf 3800 .dw DO_COLON PFA_EN_FORTHVERSION: .endif 0002d0 383c .dw XT_DOLITERAL 0002d1 0041 .dw 65 0002d2 381f .dw XT_EXIT .include "words/env-cpu.asm" ; Environment ; flash address of the CPU identification string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENV_CPU: 0002d3 ff03 .dw $ff03 0002d4 7063 0002d5 0075 .db "cpu",0 0002d6 02c9 .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENV_CPU XT_ENV_CPU: 0002d7 3800 .dw DO_COLON PFA_EN_CPU: .endif 0002d8 383c .dw XT_DOLITERAL 0002d9 0059 .dw mcu_name 0002da 0416 .dw XT_ICOUNT 0002db 381f .dw XT_EXIT .include "words/env-mcuinfo.asm" ; Environment ; flash address of some CPU specific parameters VE_ENV_MCUINFO: 0002dc ff08 .dw $ff08 0002dd 636d 0002de 2d75 0002df 6e69 0002e0 6f66 .db "mcu-info" 0002e1 02d3 .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENV_MCUINFO XT_ENV_MCUINFO: 0002e2 3800 .dw DO_COLON PFA_EN_MCUINFO: 0002e3 383c .dw XT_DOLITERAL 0002e4 0055 .dw mcu_info 0002e5 381f .dw XT_EXIT .include "words/env-usersize.asm" ; Environment ; size of the USER area in bytes .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENVUSERSIZE: 0002e6 ff05 .dw $ff05 0002e7 752f 0002e8 6573 0002e9 0072 .db "/user",0 0002ea 02dc .dw VE_ENVHEAD .set VE_ENVHEAD = VE_ENVUSERSIZE XT_ENVUSERSIZE: 0002eb 3800 .dw DO_COLON PFA_ENVUSERSIZE: .endif 0002ec 383c .dw XT_DOLITERAL 0002ed 002c .dw SYSUSERSIZE + APPUSERSIZE 0002ee 381f .dw XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/hld.asm" ; Numeric IO ; pointer to current write position in the Pictured Numeric Output buffer VE_HLD: 0002ef ff03 .dw $ff03 0002f0 6c68 0002f1 0064 .db "hld",0 0002f2 0292 .dw VE_HEAD .set VE_HEAD = VE_HLD XT_HLD: 0002f3 3847 .dw PFA_DOVARIABLE PFA_HLD: 0002f4 0199 .dw ram_hld .dseg 000199 ram_hld: .byte 2 .cseg .include "words/hold.asm" ; Numeric IO ; prepend character to pictured numeric output buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_HOLD: 0002f5 ff04 .dw $ff04 0002f6 6f68 0002f7 646c .db "hold" 0002f8 02ef .dw VE_HEAD .set VE_HEAD = VE_HOLD XT_HOLD: 0002f9 3800 .dw DO_COLON PFA_HOLD: .endif 0002fa 02f3 .dw XT_HLD 0002fb 38b0 .dw XT_DUP 0002fc 3878 .dw XT_FETCH 0002fd 3a34 .dw XT_1MINUS 0002fe 38b0 .dw XT_DUP 0002ff 38fe .dw XT_TO_R 000300 38c3 .dw XT_SWAP 000301 3880 .dw XT_STORE 000302 38f5 .dw XT_R_FROM 000303 388c .dw XT_CSTORE 000304 381f .dw XT_EXIT .include "words/less-sharp.asm" ; <# ; Numeric IO ; initialize the pictured numeric output conversion process .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_L_SHARP: 000305 ff02 .dw $ff02 000306 233c .db "<#" 000307 02f5 .dw VE_HEAD .set VE_HEAD = VE_L_SHARP XT_L_SHARP: 000308 3800 .dw DO_COLON PFA_L_SHARP: .endif 000309 3ee7 .dw XT_PAD 00030a 02f3 .dw XT_HLD 00030b 3880 .dw XT_STORE 00030c 381f .dw XT_EXIT .include "words/sharp.asm" ; Numeric IO ; pictured numeric output: convert one digit .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SHARP: 00030d ff01 .dw $ff01 00030e 0023 .db "#",0 00030f 0305 .dw VE_HEAD .set VE_HEAD = VE_SHARP XT_SHARP: 000310 3800 .dw DO_COLON PFA_SHARP: .endif 000311 3ebc .dw XT_BASE 000312 3878 .dw XT_FETCH 000313 038d .dw XT_UDSLASHMOD 000314 38e0 .dw XT_ROT 000315 383c .dw XT_DOLITERAL 000316 0009 .dw 9 000317 38ce .dw XT_OVER 000318 396d .dw XT_LESS 000319 3835 .dw XT_DOCONDBRANCH 00031a 031e DEST(PFA_SHARP1) 00031b 383c .dw XT_DOLITERAL 00031c 0007 .dw 7 00031d 399c .dw XT_PLUS PFA_SHARP1: 00031e 383c .dw XT_DOLITERAL 00031f 0030 .dw 48 ; ASCII 0 000320 399c .dw XT_PLUS 000321 02f9 .dw XT_HOLD 000322 381f .dw XT_EXIT ; : # ( ud1 -- ud2 ) ; base @ ud/mod rot 9 over < if 7 + then 30 + hold ; .include "words/sharp-s.asm" ; Numeric IO ; pictured numeric output: convert all digits until 0 (zero) is reached .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SHARP_S: 000323 ff02 .dw $ff02 000324 7323 .db "#s" 000325 030d .dw VE_HEAD .set VE_HEAD = VE_SHARP_S XT_SHARP_S: 000326 3800 .dw DO_COLON PFA_SHARP_S: .endif NUMS1: 000327 0310 .dw XT_SHARP 000328 3ec8 .dw XT_2DUP 000329 3a1b .dw XT_OR 00032a 3919 .dw XT_ZEROEQUAL 00032b 3835 .dw XT_DOCONDBRANCH 00032c 0327 DEST(NUMS1) ; PFA_SHARP_S 00032d 381f .dw XT_EXIT .include "words/sharp-greater.asm" ; #> ; Numeric IO ; Pictured Numeric Output: convert PNO buffer into an string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SHARP_G: 00032e ff02 .dw $ff02 00032f 3e23 .db "#>" 000330 0323 .dw VE_HEAD .set VE_HEAD = VE_SHARP_G XT_SHARP_G: 000331 3800 .dw DO_COLON PFA_SHARP_G: .endif 000332 3ed1 .dw XT_2DROP 000333 02f3 .dw XT_HLD 000334 3878 .dw XT_FETCH 000335 3ee7 .dw XT_PAD 000336 38ce .dw XT_OVER 000337 3992 .dw XT_MINUS 000338 381f .dw XT_EXIT .include "words/sign.asm" ; Numeric IO ; place a - in HLD if n is negative .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SIGN: 000339 ff04 .dw $ff04 00033a 6973 00033b 6e67 .db "sign" 00033c 032e .dw VE_HEAD .set VE_HEAD = VE_SIGN XT_SIGN: 00033d 3800 .dw DO_COLON PFA_SIGN: .endif 00033e 3920 .dw XT_ZEROLESS 00033f 3835 .dw XT_DOCONDBRANCH 000340 0344 DEST(PFA_SIGN1) 000341 383c .dw XT_DOLITERAL 000342 002d .dw 45 ; ascii - 000343 02f9 .dw XT_HOLD PFA_SIGN1: 000344 381f .dw XT_EXIT .include "words/d-dot-r.asm" ; Numeric IO ; singed PNO with double cell numbers, right aligned in width w .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DDOTR: 000345 ff03 .dw $ff03 000346 2e64 000347 0072 .db "d.r",0 000348 0339 .dw VE_HEAD .set VE_HEAD = VE_DDOTR XT_DDOTR: 000349 3800 .dw DO_COLON PFA_DDOTR: .endif 00034a 38fe .dw XT_TO_R 00034b 3ed9 .dw XT_TUCK 00034c 020d .dw XT_DABS 00034d 0308 .dw XT_L_SHARP 00034e 0326 .dw XT_SHARP_S 00034f 38e0 .dw XT_ROT 000350 033d .dw XT_SIGN 000351 0331 .dw XT_SHARP_G 000352 38f5 .dw XT_R_FROM 000353 38ce .dw XT_OVER 000354 3992 .dw XT_MINUS 000355 3fb6 .dw XT_SPACES 000356 0420 .dw XT_TYPE 000357 381f .dw XT_EXIT ; : d.r ( d n -- ) ; >r swap over dabs <# #s rot sign #> r> over - spaces type ; .include "words/dot-r.asm" ; Numeric IO ; singed PNO with single cell numbers, right aligned in width w .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DOTR: 000358 ff02 .dw $ff02 000359 722e .db ".r" 00035a 0345 .dw VE_HEAD .set VE_HEAD = VE_DOTR XT_DOTR: 00035b 3800 .dw DO_COLON PFA_DOTR: .endif 00035c 38fe .dw XT_TO_R 00035d 3fc6 .dw XT_S2D 00035e 38f5 .dw XT_R_FROM 00035f 0349 .dw XT_DDOTR 000360 381f .dw XT_EXIT ; : .r ( s n -- ) >r s>d r> d.r ; .include "words/d-dot.asm" ; Numeric IO ; singed PNO with double cell numbers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DDOT: 000361 ff02 .dw $ff02 000362 2e64 .db "d." 000363 0358 .dw VE_HEAD .set VE_HEAD = VE_DDOT XT_DDOT: 000364 3800 .dw DO_COLON PFA_DDOT: .endif 000365 3953 .dw XT_ZERO 000366 0349 .dw XT_DDOTR 000367 3fad .dw XT_SPACE 000368 381f .dw XT_EXIT ; : d. ( d -- ) 0 d.r space ; .include "words/dot.asm" ; Numeric IO ; singed PNO with single cell numbers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DOT: 000369 ff01 .dw $ff01 00036a 002e .db ".",0 00036b 0361 .dw VE_HEAD .set VE_HEAD = VE_DOT XT_DOT: 00036c 3800 .dw DO_COLON PFA_DOT: .endif 00036d 3fc6 .dw XT_S2D 00036e 0364 .dw XT_DDOT 00036f 381f .dw XT_EXIT ; : . ( s -- ) s>d d. ; .include "words/ud-dot.asm" ; Numeric IO ; unsigned PNO with double cell numbers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDDOT: 000370 ff03 .dw $ff03 000371 6475 000372 002e .db "ud.",0 000373 0369 .dw VE_HEAD .set VE_HEAD = VE_UDDOT XT_UDDOT: 000374 3800 .dw DO_COLON PFA_UDDOT: .endif 000375 3953 .dw XT_ZERO 000376 037d .dw XT_UDDOTR 000377 3fad .dw XT_SPACE 000378 381f .dw XT_EXIT .include "words/ud-dot-r.asm" ; Numeric IO ; unsigned PNO with double cell numbers, right aligned in width w .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDDOTR: 000379 ff04 .dw $ff04 00037a 6475 00037b 722e .db "ud.r" 00037c 0370 .dw VE_HEAD .set VE_HEAD = VE_UDDOTR XT_UDDOTR: 00037d 3800 .dw DO_COLON PFA_UDDOTR: .endif 00037e 38fe .dw XT_TO_R 00037f 0308 .dw XT_L_SHARP 000380 0326 .dw XT_SHARP_S 000381 0331 .dw XT_SHARP_G 000382 38f5 .dw XT_R_FROM 000383 38ce .dw XT_OVER 000384 3992 .dw XT_MINUS 000385 3fb6 .dw XT_SPACES 000386 0420 .dw XT_TYPE 000387 381f .dw XT_EXIT .include "words/ud-slash-mod.asm" ; Arithmetics ; unsigned double cell division with remainder .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDSLASHMOD: 000388 ff06 .dw $ff06 000389 6475 00038a 6d2f 00038b 646f .db "ud/mod" 00038c 0379 .dw VE_HEAD .set VE_HEAD = VE_UDSLASHMOD XT_UDSLASHMOD: 00038d 3800 .dw DO_COLON PFA_UDSLASHMOD: .endif 00038e 38fe .dw XT_TO_R 00038f 3953 .dw XT_ZERO 000390 3907 .dw XT_R_FETCH 000391 39c1 .dw XT_UMSLASHMOD 000392 38f5 .dw XT_R_FROM 000393 38c3 .dw XT_SWAP 000394 38fe .dw XT_TO_R 000395 39c1 .dw XT_UMSLASHMOD 000396 38f5 .dw XT_R_FROM 000397 381f .dw XT_EXIT .include "words/digit-q.asm" ; Numeric IO ; tries to convert a character to a number, set flag accordingly .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DIGITQ: 000398 ff06 .dw $ff06 000399 6964 00039a 6967 00039b 3f74 .db "digit?" 00039c 0388 .dw VE_HEAD .set VE_HEAD = VE_DIGITQ XT_DIGITQ: 00039d 3800 .dw DO_COLON PFA_DIGITQ: .endif 00039e 3f65 .dw XT_TOUPPER 00039f 38b0 0003a0 383c 0003a1 0039 0003a2 3977 0003a3 383c 0003a4 0100 .DW XT_DUP,XT_DOLITERAL,57,XT_GREATER,XT_DOLITERAL,256 0003a5 3a12 0003a6 399c 0003a7 38b0 0003a8 383c 0003a9 0140 0003aa 3977 .DW XT_AND,XT_PLUS,XT_DUP,XT_DOLITERAL,320,XT_GREATER 0003ab 383c 0003ac 0107 0003ad 3a12 0003ae 3992 0003af 383c 0003b0 0030 .DW XT_DOLITERAL,263,XT_AND,XT_MINUS,XT_DOLITERAL,48 0003b1 3992 0003b2 38b0 0003b3 3ebc 0003b4 3878 0003b5 395b .DW XT_MINUS,XT_DUP,XT_BASE,XT_FETCH,XT_ULESS 0003b6 381f .DW XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/do-sliteral.asm" ; String ; runtime portion of sliteral ;VE_DOSLITERAL: ; .dw $ff0a ; .db "(sliteral)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOSLITERAL XT_DOSLITERAL: 0003b7 3800 .dw DO_COLON PFA_DOSLITERAL: 0003b8 3907 .dw XT_R_FETCH ; ( -- addr ) 0003b9 0416 .dw XT_ICOUNT 0003ba 38f5 .dw XT_R_FROM 0003bb 38ce .dw XT_OVER ; ( -- addr' n addr n) 0003bc 3a2e .dw XT_1PLUS 0003bd 3a03 .dw XT_2SLASH ; ( -- addr' n addr k ) 0003be 399c .dw XT_PLUS ; ( -- addr' n addr'' ) 0003bf 3a2e .dw XT_1PLUS 0003c0 38fe .dw XT_TO_R ; ( -- ) 0003c1 381f .dw XT_EXIT .include "words/scomma.asm" ; Compiler ; compiles a string from RAM to Flash VE_SCOMMA: 0003c2 ff02 .dw $ff02 0003c3 2c73 .db "s",$2c 0003c4 0398 .dw VE_HEAD .set VE_HEAD = VE_SCOMMA XT_SCOMMA: 0003c5 3800 .dw DO_COLON PFA_SCOMMA: 0003c6 38b0 .dw XT_DUP 0003c7 03c9 .dw XT_DOSCOMMA 0003c8 381f .dw XT_EXIT ; ( addr len len' -- ) ; Compiler ; compiles a string from RAM to Flash ;VE_DOSCOMMA: ; .dw $ff04 ; .db "(s",$2c,")" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOSCOMMA XT_DOSCOMMA: 0003c9 3800 .dw DO_COLON PFA_DOSCOMMA: 0003ca 074e .dw XT_COMMA 0003cb 38b0 .dw XT_DUP ; ( --addr len len) 0003cc 3a03 .dw XT_2SLASH ; ( -- addr len len/2 0003cd 3ed9 .dw XT_TUCK ; ( -- addr len/2 len len/2 0003ce 3a0a .dw XT_2STAR ; ( -- addr len/2 len len' 0003cf 3992 .dw XT_MINUS ; ( -- addr len/2 rem 0003d0 38fe .dw XT_TO_R 0003d1 3953 .dw XT_ZERO 0003d2 080d .dw XT_QDOCHECK 0003d3 3835 .dw XT_DOCONDBRANCH 0003d4 03dc .dw PFA_SCOMMA2 0003d5 3a9a .dw XT_DODO PFA_SCOMMA1: 0003d6 38b0 .dw XT_DUP ; ( -- addr addr ) 0003d7 3878 .dw XT_FETCH ; ( -- addr c1c2 ) 0003d8 074e .dw XT_COMMA ; ( -- addr ) 0003d9 3c8f .dw XT_CELLPLUS ; ( -- addr+cell ) 0003da 3ac8 .dw XT_DOLOOP 0003db 03d6 .dw PFA_SCOMMA1 PFA_SCOMMA2: 0003dc 38f5 .dw XT_R_FROM 0003dd 3927 .dw XT_GREATERZERO 0003de 3835 .dw XT_DOCONDBRANCH 0003df 03e3 .dw PFA_SCOMMA3 0003e0 38b0 .dw XT_DUP ; well, tricky 0003e1 3897 .dw XT_CFETCH 0003e2 074e .dw XT_COMMA PFA_SCOMMA3: 0003e3 38d8 .dw XT_DROP ; ( -- ) 0003e4 381f .dw XT_EXIT .include "words/itype.asm" ; Tools ; reads string from flash and prints it VE_ITYPE: 0003e5 ff05 .dw $ff05 0003e6 7469 0003e7 7079 0003e8 0065 .db "itype",0 0003e9 03c2 .dw VE_HEAD .set VE_HEAD = VE_ITYPE XT_ITYPE: 0003ea 3800 .dw DO_COLON PFA_ITYPE: 0003eb 38b0 .dw XT_DUP ; ( --addr len len) 0003ec 3a03 .dw XT_2SLASH ; ( -- addr len len/2 0003ed 3ed9 .dw XT_TUCK ; ( -- addr len/2 len len/2 0003ee 3a0a .dw XT_2STAR ; ( -- addr len/2 len len' 0003ef 3992 .dw XT_MINUS ; ( -- addr len/2 rem 0003f0 38fe .dw XT_TO_R 0003f1 3953 .dw XT_ZERO 0003f2 080d .dw XT_QDOCHECK 0003f3 3835 .dw XT_DOCONDBRANCH 0003f4 03fe .dw PFA_ITYPE2 0003f5 3a9a .dw XT_DODO PFA_ITYPE1: 0003f6 38b0 .dw XT_DUP ; ( -- addr addr ) 0003f7 3bca .dw XT_FETCHI ; ( -- addr c1c2 ) 0003f8 38b0 .dw XT_DUP 0003f9 040b .dw XT_LOWEMIT 0003fa 0407 .dw XT_HIEMIT 0003fb 3a2e .dw XT_1PLUS ; ( -- addr+cell ) 0003fc 3ac8 .dw XT_DOLOOP 0003fd 03f6 .dw PFA_ITYPE1 PFA_ITYPE2: 0003fe 38f5 .dw XT_R_FROM 0003ff 3927 .dw XT_GREATERZERO 000400 3835 .dw XT_DOCONDBRANCH 000401 0405 .dw PFA_ITYPE3 000402 38b0 .dw XT_DUP ; make sure the drop below has always something to do 000403 3bca .dw XT_FETCHI 000404 040b .dw XT_LOWEMIT PFA_ITYPE3: 000405 38d8 .dw XT_DROP 000406 381f .dw XT_EXIT ; ( w -- ) ; R( -- ) ; content of cell fetched on stack. ;VE_HIEMIT: ; .dw $ff06 ; .db "hiemit" ; .dw VE_HEAD ; .set VE_HEAD = VE_HIEMIT XT_HIEMIT: 000407 3800 .dw DO_COLON PFA_HIEMIT: 000408 3af8 .dw XT_BYTESWAP 000409 040b .dw XT_LOWEMIT 00040a 381f .dw XT_EXIT ; ( w -- ) ; R( -- ) ; content of cell fetched on stack. ;VE_LOWEMIT: ; .dw $ff07 ; .db "lowemit" ; .dw VE_HEAD ; .set VE_HEAD = VE_LOWEMIT XT_LOWEMIT: 00040b 3800 .dw DO_COLON PFA_LOWEMIT: 00040c 383c .dw XT_DOLITERAL 00040d 00ff .dw $00ff 00040e 3a12 .dw XT_AND 00040f 3ef1 .dw XT_EMIT 000410 381f .dw XT_EXIT .include "words/icount.asm" ; Tools ; get count information out of a counted string in flash VE_ICOUNT: 000411 ff06 .dw $ff06 000412 6369 000413 756f 000414 746e .db "icount" 000415 03e5 .dw VE_HEAD .set VE_HEAD = VE_ICOUNT XT_ICOUNT: 000416 3800 .dw DO_COLON PFA_ICOUNT: 000417 38b0 .dw XT_DUP 000418 3a2e .dw XT_1PLUS 000419 38c3 .dw XT_SWAP 00041a 3bca .dw XT_FETCHI 00041b 381f .dw XT_EXIT .include "words/type.asm" ; Character IO ; print a RAM based string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TYPE: 00041c ff04 .dw $ff04 00041d 7974 00041e 6570 .db "type" 00041f 0411 .dw VE_HEAD .set VE_HEAD = VE_TYPE XT_TYPE: 000420 3800 .dw DO_COLON PFA_TYPE: .endif 000421 3f98 .dw XT_BOUNDS 000422 080d .dw XT_QDOCHECK 000423 3835 .dw XT_DOCONDBRANCH 000424 042b DEST(PFA_TYPE2) 000425 3a9a .dw XT_DODO PFA_TYPE1: 000426 3aab .dw XT_I 000427 3897 .dw XT_CFETCH 000428 3ef1 .dw XT_EMIT 000429 3ac8 .dw XT_DOLOOP 00042a 0426 DEST(PFA_TYPE1) PFA_TYPE2: 00042b 381f .dw XT_EXIT .include "words/tick.asm" ; Dictionary ; search dictionary for name, return XT or throw an exception -13 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TICK: 00042c ff01 .dw $ff01 00042d 0027 .db "'",0 00042e 041c .dw VE_HEAD .set VE_HEAD = VE_TICK XT_TICK: 00042f 3800 .dw DO_COLON PFA_TICK: .endif 000430 05a2 .dw XT_PARSENAME 000431 05e5 .dw XT_FORTHRECOGNIZER 000432 05f0 .dw XT_RECOGNIZE ; a word is tickable unless DT:TOKEN is DT:NULL or ; the interpret action is a NOOP 000433 38b0 .dw XT_DUP 000434 067d .dw XT_DT_NULL 000435 3fde .dw XT_EQUAL 000436 38c3 .dw XT_SWAP 000437 3bca .dw XT_FETCHI 000438 383c .dw XT_DOLITERAL 000439 017b .dw XT_NOOP 00043a 3fde .dw XT_EQUAL 00043b 3a1b .dw XT_OR 00043c 3835 .dw XT_DOCONDBRANCH 00043d 0441 DEST(PFA_TICK1) 00043e 383c .dw XT_DOLITERAL 00043f fff3 .dw -13 000440 3d85 .dw XT_THROW PFA_TICK1: 000441 38d8 .dw XT_DROP 000442 381f .dw XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/cskip.asm" ; String ; skips leading occurancies in string at addr1/n1 leaving addr2/n2 pointing to the 1st non-c character .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CSKIP: 000443 ff05 .dw $ff05 000444 7363 000445 696b 000446 0070 .db "cskip",0 000447 042c .dw VE_HEAD .set VE_HEAD = VE_CSKIP XT_CSKIP: 000448 3800 .dw DO_COLON PFA_CSKIP: .endif 000449 38fe .dw XT_TO_R ; ( -- addr1 n1 ) PFA_CSKIP1: 00044a 38b0 .dw XT_DUP ; ( -- addr' n' n' ) 00044b 3835 .dw XT_DOCONDBRANCH ; ( -- addr' n') 00044c 0457 DEST(PFA_CSKIP2) 00044d 38ce .dw XT_OVER ; ( -- addr' n' addr' ) 00044e 3897 .dw XT_CFETCH ; ( -- addr' n' c' ) 00044f 3907 .dw XT_R_FETCH ; ( -- addr' n' c' c ) 000450 3fde .dw XT_EQUAL ; ( -- addr' n' f ) 000451 3835 .dw XT_DOCONDBRANCH ; ( -- addr' n') 000452 0457 DEST(PFA_CSKIP2) 000453 3fe5 .dw XT_ONE 000454 0593 .dw XT_SLASHSTRING 000455 382e .dw XT_DOBRANCH 000456 044a DEST(PFA_CSKIP1) PFA_CSKIP2: 000457 38f5 .dw XT_R_FROM 000458 38d8 .dw XT_DROP ; ( -- addr2 n2) 000459 381f .dw XT_EXIT .include "words/cscan.asm" ; String ; Scan string at addr1/n1 for the first occurance of c, leaving addr1/n2, char at n2 is first non-c character .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CSCAN: 00045a ff05 .dw $ff05 00045b 7363 00045c 6163 ../../common\words/cscan.asm(12): warning: .cseg .db misalignment - padding zero byte 00045d 006e .db "cscan" 00045e 0443 .dw VE_HEAD .set VE_HEAD = VE_CSCAN XT_CSCAN: 00045f 3800 .dw DO_COLON PFA_CSCAN: .endif 000460 38fe .dw XT_TO_R 000461 38ce .dw XT_OVER PFA_CSCAN1: 000462 38b0 .dw XT_DUP 000463 3897 .dw XT_CFETCH 000464 3907 .dw XT_R_FETCH 000465 3fde .dw XT_EQUAL 000466 3919 .dw XT_ZEROEQUAL 000467 3835 .dw XT_DOCONDBRANCH 000468 0474 DEST(PFA_CSCAN2) 000469 38c3 .dw XT_SWAP 00046a 3a34 .dw XT_1MINUS 00046b 38c3 .dw XT_SWAP 00046c 38ce .dw XT_OVER 00046d 3920 .dw XT_ZEROLESS ; not negative 00046e 3919 .dw XT_ZEROEQUAL 00046f 3835 .dw XT_DOCONDBRANCH 000470 0474 DEST(PFA_CSCAN2) 000471 3a2e .dw XT_1PLUS 000472 382e .dw XT_DOBRANCH 000473 0462 DEST(PFA_CSCAN1) PFA_CSCAN2: 000474 38ef .dw XT_NIP 000475 38ce .dw XT_OVER 000476 3992 .dw XT_MINUS 000477 38f5 .dw XT_R_FROM 000478 38d8 .dw XT_DROP 000479 381f .dw XT_EXIT ; : my-cscan ( addr len c -- addr len' ) ; >r over ( -- addr len addr ) ; begin ; dup c@ r@ <> while ; swap 1- swap over 0 >= while ; 1+ ; repeat then ; nip over - r> drop ; ; .include "words/accept.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ACCEPT: 00047a ff06 .dw $ff06 00047b 6361 00047c 6563 00047d 7470 .db "accept" 00047e 045a .dw VE_HEAD .set VE_HEAD = VE_ACCEPT XT_ACCEPT: 00047f 3800 .dw DO_COLON PFA_ACCEPT: .endif 000480 38ce 000481 399c 000482 3a34 000483 38ce .DW XT_OVER,XT_PLUS,XT_1MINUS,XT_OVER 000484 3f02 000485 38b0 000486 04c0 000487 3919 000488 3835 ACC1: .DW XT_KEY,XT_DUP,XT_CRLFQ,XT_ZEROEQUAL,XT_DOCONDBRANCH 000489 04b2 DEST(ACC5) 00048a 38b0 00048b 383c 00048c 0008 00048d 3fde 00048e 3835 .DW XT_DUP,XT_DOLITERAL,8,XT_EQUAL,XT_DOCONDBRANCH 00048f 04a2 DEST(ACC3) 000490 38d8 000491 38e0 000492 3ec8 000493 3977 000494 38fe 000495 38e0 000496 38e0 000497 38f5 000498 3835 .DW XT_DROP,XT_ROT,XT_2DUP,XT_GREATER,XT_TO_R,XT_ROT,XT_ROT,XT_R_FROM,XT_DOCONDBRANCH 000499 04a0 DEST(ACC6) 00049a 04b8 00049b 3a34 00049c 38fe 00049d 38ce 00049e 38f5 00049f 0130 .DW XT_BS,XT_1MINUS,XT_TO_R,XT_OVER,XT_R_FROM,XT_UMAX 0004a0 382e ACC6: .DW XT_DOBRANCH 0004a1 04b0 DEST(ACC4) ACC3: ; check for remaining control characters, replace them with blank 0004a2 38b0 .dw XT_DUP ; ( -- addr k k ) 0004a3 3f53 .dw XT_BL 0004a4 396d .dw XT_LESS 0004a5 3835 .dw XT_DOCONDBRANCH 0004a6 04a9 DEST(PFA_ACCEPT6) 0004a7 38d8 .dw XT_DROP 0004a8 3f53 .dw XT_BL PFA_ACCEPT6: 0004a9 38b0 0004aa 3ef1 0004ab 38ce 0004ac 388c 0004ad 3a2e 0004ae 38ce 0004af 013c .DW XT_DUP,XT_EMIT,XT_OVER,XT_CSTORE,XT_1PLUS,XT_OVER,XT_UMIN 0004b0 382e ACC4: .DW XT_DOBRANCH 0004b1 0484 DEST(ACC1) 0004b2 38d8 0004b3 38ef 0004b4 38c3 0004b5 3992 0004b6 3fa0 0004b7 381f ACC5: .DW XT_DROP,XT_NIP,XT_SWAP,XT_MINUS,XT_CR,XT_EXIT ; ( -- ) ; System ; send a backspace character to overwrite the current char .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_BS: ; .dw $ff02 ; .db "bs" ; .dw VE_HEAD ; .set VE_HEAD = VE_BS XT_BS: 0004b8 3800 .dw DO_COLON .endif 0004b9 383c .dw XT_DOLITERAL 0004ba 0008 .dw 8 0004bb 38b0 .dw XT_DUP 0004bc 3ef1 .dw XT_EMIT 0004bd 3fad .dw XT_SPACE 0004be 3ef1 .dw XT_EMIT 0004bf 381f .dw XT_EXIT ; ( c -- f ) ; System ; is the character a line end character? .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_CRLFQ: ; .dw $ff02 ; .db "crlf?" ; .dw VE_HEAD ; .set VE_HEAD = VE_CRLFQ XT_CRLFQ: 0004c0 3800 .dw DO_COLON .endif 0004c1 38b0 .dw XT_DUP 0004c2 383c .dw XT_DOLITERAL 0004c3 000d .dw 13 0004c4 3fde .dw XT_EQUAL 0004c5 38c3 .dw XT_SWAP 0004c6 383c .dw XT_DOLITERAL 0004c7 000a .dw 10 0004c8 3fde .dw XT_EQUAL 0004c9 3a1b .dw XT_OR 0004ca 381f .dw XT_EXIT .include "words/refill.asm" ; System ; refills the input buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_REFILL: 0004cb ff06 .dw $ff06 0004cc 6572 0004cd 6966 0004ce 6c6c .db "refill" 0004cf 047a .dw VE_HEAD .set VE_HEAD = VE_REFILL XT_REFILL: 0004d0 3dfe .dw PFA_DODEFER1 PFA_REFILL: .endif 0004d1 001a .dw USER_REFILL 0004d2 3dc7 .dw XT_UDEFERFETCH 0004d3 3dd3 .dw XT_UDEFERSTORE .include "words/char.asm" ; Tools ; copy the first character of the next word onto the stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CHAR: 0004d4 ff04 .dw $ff04 0004d5 6863 0004d6 7261 .db "char" 0004d7 04cb .dw VE_HEAD .set VE_HEAD = VE_CHAR XT_CHAR: 0004d8 3800 .dw DO_COLON PFA_CHAR: .endif 0004d9 05a2 .dw XT_PARSENAME 0004da 38d8 .dw XT_DROP 0004db 3897 .dw XT_CFETCH 0004dc 381f .dw XT_EXIT .include "words/number.asm" ; Numeric IO ; convert a string at addr to a number .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_NUMBER: 0004dd ff06 .dw $ff06 0004de 756e 0004df 626d 0004e0 7265 .db "number" 0004e1 04d4 .dw VE_HEAD .set VE_HEAD = VE_NUMBER XT_NUMBER: 0004e2 3800 .dw DO_COLON PFA_NUMBER: .endif 0004e3 3ebc .dw XT_BASE 0004e4 3878 .dw XT_FETCH 0004e5 38fe .dw XT_TO_R 0004e6 0526 .dw XT_QSIGN 0004e7 38fe .dw XT_TO_R 0004e8 0539 .dw XT_SET_BASE 0004e9 0526 .dw XT_QSIGN 0004ea 38f5 .dw XT_R_FROM 0004eb 3a1b .dw XT_OR 0004ec 38fe .dw XT_TO_R ; check whether something is left 0004ed 38b0 .dw XT_DUP 0004ee 3919 .dw XT_ZEROEQUAL 0004ef 3835 .dw XT_DOCONDBRANCH 0004f0 04f9 DEST(PFA_NUMBER0) ; nothing is left. It cannot be a number at all 0004f1 3ed1 .dw XT_2DROP 0004f2 38f5 .dw XT_R_FROM 0004f3 38d8 .dw XT_DROP 0004f4 38f5 .dw XT_R_FROM 0004f5 3ebc .dw XT_BASE 0004f6 3880 .dw XT_STORE 0004f7 3953 .dw XT_ZERO 0004f8 381f .dw XT_EXIT PFA_NUMBER0: 0004f9 3b1d .dw XT_2TO_R 0004fa 3953 .dw XT_ZERO ; starting value 0004fb 3953 .dw XT_ZERO 0004fc 3b2c .dw XT_2R_FROM 0004fd 0557 .dw XT_TO_NUMBER ; ( 0. addr len -- d addr' len' ; check length of the remaining string. ; if zero: a single cell number is entered 0004fe 38b8 .dw XT_QDUP 0004ff 3835 .dw XT_DOCONDBRANCH 000500 051b DEST(PFA_NUMBER1) ; if equal 1: mayba a trailing dot? --> double cell number 000501 3fe5 .dw XT_ONE 000502 3fde .dw XT_EQUAL 000503 3835 .dw XT_DOCONDBRANCH 000504 0512 DEST(PFA_NUMBER2) ; excatly one character is left 000505 3897 .dw XT_CFETCH 000506 383c .dw XT_DOLITERAL 000507 002e .dw 46 ; . 000508 3fde .dw XT_EQUAL 000509 3835 .dw XT_DOCONDBRANCH 00050a 0513 DEST(PFA_NUMBER6) ; its a double cell number ; incorporate sign into number 00050b 38f5 .dw XT_R_FROM 00050c 3835 .dw XT_DOCONDBRANCH 00050d 050f DEST(PFA_NUMBER3) 00050e 021a .dw XT_DNEGATE PFA_NUMBER3: 00050f 3fea .dw XT_TWO 000510 382e .dw XT_DOBRANCH 000511 0521 DEST(PFA_NUMBER5) PFA_NUMBER2: 000512 38d8 .dw XT_DROP PFA_NUMBER6: 000513 3ed1 .dw XT_2DROP 000514 38f5 .dw XT_R_FROM 000515 38d8 .dw XT_DROP 000516 38f5 .dw XT_R_FROM 000517 3ebc .dw XT_BASE 000518 3880 .dw XT_STORE 000519 3953 .dw XT_ZERO 00051a 381f .dw XT_EXIT PFA_NUMBER1: 00051b 3ed1 .dw XT_2DROP ; remove the address ; incorporate sign into number 00051c 38f5 .dw XT_R_FROM 00051d 3835 .dw XT_DOCONDBRANCH 00051e 0520 DEST(PFA_NUMBER4) 00051f 3e26 .dw XT_NEGATE PFA_NUMBER4: 000520 3fe5 .dw XT_ONE PFA_NUMBER5: 000521 38f5 .dw XT_R_FROM 000522 3ebc .dw XT_BASE 000523 3880 .dw XT_STORE 000524 394a .dw XT_TRUE 000525 381f .dw XT_EXIT .include "words/q-sign.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_QSIGN: 000526 3800 .dw DO_COLON PFA_QSIGN: ; ( c -- ) .endif 000527 38ce .dw XT_OVER ; ( -- addr len addr ) 000528 3897 .dw XT_CFETCH 000529 383c .dw XT_DOLITERAL 00052a 002d .dw '-' 00052b 3fde .dw XT_EQUAL ; ( -- addr len flag ) 00052c 38b0 .dw XT_DUP 00052d 38fe .dw XT_TO_R 00052e 3835 .dw XT_DOCONDBRANCH 00052f 0532 DEST(PFA_NUMBERSIGN_DONE) 000530 3fe5 .dw XT_ONE ; skip sign character 000531 0593 .dw XT_SLASHSTRING PFA_NUMBERSIGN_DONE: 000532 38f5 .dw XT_R_FROM 000533 381f .dw XT_EXIT .include "words/set-base.asm" ; Numeric IO ; skip a numeric prefix character .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_BASES: 000534 3851 .dw PFA_DOCONSTANT .endif 000535 000a 000536 0010 000537 0002 000538 000a .dw 10,16,2,10 ; last one could a 8 instead. .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_SET_BASE: 000539 3800 .dw DO_COLON PFA_SET_BASE: ; ( adr1 len1 -- adr2 len2 ) .endif 00053a 38ce .dw XT_OVER 00053b 3897 .dw XT_CFETCH 00053c 383c .dw XT_DOLITERAL 00053d 0023 .dw 35 00053e 3992 .dw XT_MINUS 00053f 38b0 .dw XT_DUP 000540 3953 .dw XT_ZERO 000541 383c .dw XT_DOLITERAL 000542 0004 .dw 4 000543 3e56 .dw XT_WITHIN 000544 3835 .dw XT_DOCONDBRANCH 000545 054f DEST(SET_BASE1) .if cpu_msp430==1 .endif 000546 0534 .dw XT_BASES 000547 399c .dw XT_PLUS 000548 3bca .dw XT_FETCHI 000549 3ebc .dw XT_BASE 00054a 3880 .dw XT_STORE 00054b 3fe5 .dw XT_ONE 00054c 0593 .dw XT_SLASHSTRING 00054d 382e .dw XT_DOBRANCH 00054e 0550 DEST(SET_BASE2) SET_BASE1: 00054f 38d8 .dw XT_DROP SET_BASE2: 000550 381f .dw XT_EXIT ; create bases 10 , 16 , 2 , 8 , ; : set-base 35 - dup 0 4 within if ; bases + @i base ! 1 /string ; else ; drop ; then ; .include "words/to-number.asm" ; Numeric IO ; convert a string to a number c-addr2/u2 is the unconverted string .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TO_NUMBER: 000551 ff07 .dw $ff07 000552 6e3e 000553 6d75 000554 6562 000555 0072 .db ">number",0 000556 04dd .dw VE_HEAD .set VE_HEAD = VE_TO_NUMBER XT_TO_NUMBER: 000557 3800 .dw DO_COLON .endif 000558 38b0 000559 3835 TONUM1: .DW XT_DUP,XT_DOCONDBRANCH 00055a 056f DEST(TONUM3) 00055b 38ce 00055c 3897 00055d 039d .DW XT_OVER,XT_CFETCH,XT_DIGITQ 00055e 3919 00055f 3835 .DW XT_ZEROEQUAL,XT_DOCONDBRANCH 000560 0563 DEST(TONUM2) 000561 38d8 000562 381f .DW XT_DROP,XT_EXIT 000563 38fe 000564 023e 000565 3ebc 000566 3878 000567 0121 TONUM2: .DW XT_TO_R,XT_2SWAP,XT_BASE,XT_FETCH,XT_UDSTAR 000568 38f5 000569 0119 00056a 023e .DW XT_R_FROM,XT_MPLUS,XT_2SWAP 00056b 3fe5 00056c 0593 00056d 382e .DW XT_ONE,XT_SLASHSTRING,XT_DOBRANCH 00056e 0558 DEST(TONUM1) 00056f 381f TONUM3: .DW XT_EXIT ;C >NUMBER ud adr u -- ud' adr' u' ;C convert string to number ; BEGIN ; DUP WHILE ; OVER C@ DIGIT? ; 0= IF DROP EXIT THEN ; >R 2SWAP BASE @ UD* ; R> M+ 2SWAP ; 1 /STRING ; REPEAT ; .include "words/parse.asm" ; String ; in input buffer parse ccc delimited string by the delimiter char. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PARSE: 000570 ff05 .dw $ff05 000571 6170 000572 7372 000573 0065 .db "parse",0 000574 0551 .dw VE_HEAD .set VE_HEAD = VE_PARSE XT_PARSE: 000575 3800 .dw DO_COLON PFA_PARSE: .endif 000576 38fe .dw XT_TO_R ; ( -- ) 000577 0589 .dw XT_SOURCE ; ( -- addr len) 000578 3ee1 .dw XT_TO_IN ; ( -- addr len >in) 000579 3878 .dw XT_FETCH 00057a 0593 .dw XT_SLASHSTRING ; ( -- addr' len' ) 00057b 38f5 .dw XT_R_FROM ; ( -- addr' len' c) 00057c 045f .dw XT_CSCAN ; ( -- addr' len'') 00057d 38b0 .dw XT_DUP ; ( -- addr' len'' len'') 00057e 3a2e .dw XT_1PLUS 00057f 3ee1 .dw XT_TO_IN ; ( -- addr' len'' len'' >in) 000580 3a64 .dw XT_PLUSSTORE ; ( -- addr' len') 000581 3fe5 .dw XT_ONE 000582 0593 .dw XT_SLASHSTRING 000583 381f .dw XT_EXIT .include "words/source.asm" ; System ; address and current length of the input buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SOURCE: 000584 ff06 .dw $FF06 000585 6f73 000586 7275 000587 6563 .db "source" 000588 0570 .dw VE_HEAD .set VE_HEAD = VE_SOURCE XT_SOURCE: 000589 3dfe .dw PFA_DODEFER1 PFA_SOURCE: .endif 00058a 0016 .dw USER_SOURCE 00058b 3dc7 .dw XT_UDEFERFETCH 00058c 3dd3 .dw XT_UDEFERSTORE .include "words/slash-string.asm" ; String ; adjust string from addr1 to addr1+n, reduce length from u1 to u2 by n .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SLASHSTRING: 00058d ff07 .dw $ff07 00058e 732f 00058f 7274 000590 6e69 000591 0067 .db "/string",0 000592 0584 .dw VE_HEAD .set VE_HEAD = VE_SLASHSTRING XT_SLASHSTRING: 000593 3800 .dw DO_COLON PFA_SLASHSTRING: .endif 000594 38e0 .dw XT_ROT 000595 38ce .dw XT_OVER 000596 399c .dw XT_PLUS 000597 38e0 .dw XT_ROT 000598 38e0 .dw XT_ROT 000599 3992 .dw XT_MINUS 00059a 381f .dw XT_EXIT .include "words/parse-name.asm" ; String ; In the SOURCE buffer parse whitespace delimited string. Returns string address within SOURCE. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PARSENAME: 00059b ff0a .dw $FF0A 00059c 6170 00059d 7372 00059e 2d65 00059f 616e 0005a0 656d .db "parse-name" 0005a1 058d .dw VE_HEAD .set VE_HEAD = VE_PARSENAME XT_PARSENAME: 0005a2 3800 .dw DO_COLON PFA_PARSENAME: .endif 0005a3 3f53 .dw XT_BL 0005a4 05a6 .dw XT_SKIPSCANCHAR 0005a5 381f .dw XT_EXIT ; ( c -- addr2 len2 ) ; String ; skips char and scan what's left in source for char .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_SKIPSCANCHAR: ; .dw $FF0A ; .db "skipscanchar" ; .dw VE_HEAD ; .set VE_HEAD = VE_SKIPSCANCHAR XT_SKIPSCANCHAR: 0005a6 3800 .dw DO_COLON PFA_SKIPSCANCHAR: .endif 0005a7 38fe .dw XT_TO_R 0005a8 0589 .dw XT_SOURCE 0005a9 3ee1 .dw XT_TO_IN 0005aa 3878 .dw XT_FETCH 0005ab 0593 .dw XT_SLASHSTRING 0005ac 3907 .dw XT_R_FETCH 0005ad 0448 .dw XT_CSKIP 0005ae 38f5 .dw XT_R_FROM 0005af 045f .dw XT_CSCAN ; adjust >IN 0005b0 3ec8 .dw XT_2DUP 0005b1 399c .dw XT_PLUS 0005b2 0589 .dw XT_SOURCE 0005b3 38d8 .dw XT_DROP 0005b4 3992 .dw XT_MINUS 0005b5 3ee1 .dw XT_TO_IN 0005b6 3880 .dw XT_STORE 0005b7 381f .dw XT_EXIT .include "words/sp0.asm" ; Stack ; start address of the data stack VE_SP0: 0005b8 ff03 .dw $ff03 0005b9 7073 0005ba 0030 .db "sp0",0 0005bb 059b .dw VE_HEAD .set VE_HEAD = VE_SP0 XT_SP0: 0005bc 386e .dw PFA_DOVALUE1 PFA_SP0: 0005bd 0006 .dw USER_SP0 0005be 3dc7 .dw XT_UDEFERFETCH 0005bf 3dd3 .dw XT_UDEFERSTORE ; ( -- addr) ; Stack ; address of user variable to store top-of-stack for inactive tasks VE_SP: 0005c0 ff02 .dw $ff02 0005c1 7073 .db "sp" 0005c2 05b8 .dw VE_HEAD .set VE_HEAD = VE_SP XT_SP: 0005c3 3857 .dw PFA_DOUSER PFA_SP: 0005c4 0008 .dw USER_SP .include "words/rp0.asm" ; Stack ; start address of return stack VE_RP0: 0005c5 ff03 .dw $ff03 0005c6 7072 0005c7 0030 .db "rp0",0 0005c8 05c0 .dw VE_HEAD .set VE_HEAD = VE_RP0 XT_RP0: 0005c9 3800 .dw DO_COLON PFA_RP0: 0005ca 05cd .dw XT_DORP0 0005cb 3878 .dw XT_FETCH 0005cc 381f .dw XT_EXIT ; ( -- addr) ; Stack ; user variable of the address of the initial return stack ;VE_DORP0: ; .dw $ff05 ; .db "(rp0)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DORP0 XT_DORP0: 0005cd 3857 .dw PFA_DOUSER PFA_DORP0: 0005ce 0004 .dw USER_RP .include "words/depth.asm" ; Stack ; number of single-cell values contained in the data stack before n was placed on the stack. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DEPTH: 0005cf ff05 .dw $ff05 0005d0 6564 0005d1 7470 0005d2 0068 .db "depth",0 0005d3 05c5 .dw VE_HEAD .set VE_HEAD = VE_DEPTH XT_DEPTH: 0005d4 3800 .dw DO_COLON PFA_DEPTH: .endif 0005d5 05bc .dw XT_SP0 0005d6 3a8c .dw XT_SP_FETCH 0005d7 3992 .dw XT_MINUS 0005d8 3a03 .dw XT_2SLASH 0005d9 3a34 .dw XT_1MINUS 0005da 381f .dw XT_EXIT .include "words/forth-recognizer.asm" ; System Value ; address of the next free data space (RAM) cell VE_FORTHRECOGNIZER: 0005db ff10 .dw $ff10 0005dc 6f66 0005dd 7472 0005de 2d68 0005df 6572 0005e0 6f63 0005e1 6e67 0005e2 7a69 0005e3 7265 .db "forth-recognizer" 0005e4 05cf .dw VE_HEAD .set VE_HEAD = VE_FORTHRECOGNIZER XT_FORTHRECOGNIZER: 0005e5 386e .dw PFA_DOVALUE1 PFA_FORTHRECOGNIZER: 0005e6 0060 .dw CFG_FORTHRECOGNIZER 0005e7 3d9f .dw XT_EDEFERFETCH 0005e8 3da9 .dw XT_EDEFERSTORE .include "words/recognize.asm" ; System ; walk the recognizer stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_RECOGNIZE: 0005e9 ff09 .dw $ff09 0005ea 6572 0005eb 6f63 0005ec 6e67 0005ed 7a69 0005ee 0065 .db "recognize",0 0005ef 05db .dw VE_HEAD .set VE_HEAD = VE_RECOGNIZE XT_RECOGNIZE: 0005f0 3800 .dw DO_COLON PFA_RECOGNIZE: .endif 0005f1 383c .dw XT_DOLITERAL 0005f2 05fb .dw XT_RECOGNIZE_A 0005f3 38c3 .dw XT_SWAP 0005f4 098e .dw XT_MAPSTACK 0005f5 3919 .dw XT_ZEROEQUAL 0005f6 3835 .dw XT_DOCONDBRANCH 0005f7 05fa DEST(PFA_RECOGNIZE1) 0005f8 3ed1 .dw XT_2DROP 0005f9 067d .dw XT_DT_NULL PFA_RECOGNIZE1: 0005fa 381f .dw XT_EXIT .if cpu_msp430==1 .endif .if cpu_avr8==1 ; ( addr len XT -- addr len [ dt:xt -1 | 0 ] ) XT_RECOGNIZE_A: 0005fb 3800 .dw DO_COLON PFA_RECOGNIZE_A: .endif 0005fc 38e0 .dw XT_ROT ; -- len xt addr 0005fd 38e0 .dw XT_ROT ; -- xt addr len 0005fe 3ec8 .dw XT_2DUP 0005ff 3b1d .dw XT_2TO_R 000600 38e0 .dw XT_ROT ; -- addr len xt 000601 3829 .dw XT_EXECUTE ; -- i*x dt:* | dt:null 000602 3b2c .dw XT_2R_FROM 000603 38e0 .dw XT_ROT 000604 38b0 .dw XT_DUP 000605 067d .dw XT_DT_NULL 000606 3fde .dw XT_EQUAL 000607 3835 .dw XT_DOCONDBRANCH 000608 060c DEST(PFA_RECOGNIZE_A1) 000609 38d8 .dw XT_DROP 00060a 3953 .dw XT_ZERO 00060b 381f .dw XT_EXIT PFA_RECOGNIZE_A1: 00060c 38ef .dw XT_NIP 00060d 38ef .dw XT_NIP 00060e 394a .dw XT_TRUE 00060f 381f .dw XT_EXIT ; : recognize ( addr len stack-id -- i*x dt:* | dt:null ) ; [: ( addr len -- addr len 0 | i*x dt:* -1 ) ; rot rot 2dup 2>r rot execute 2r> rot ; dup dt:null = ( -- addr len dt:* f ) ; if drop 0 else nip nip -1 then ; ;] ; map-stack ( -- i*x addr len dt:* f ) ; 0= if \ a recognizer did the job, remove addr/len ; 2drop dt:null ; then ; ; .include "words/interpret.asm" ; System ; Interpret SOURCE word by word. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_INTERPRET: 000610 ff09 .dw $ff09 000611 6e69 000612 6574 000613 7072 000614 6572 000615 0074 .db "interpret",0 000616 05e9 .dw VE_HEAD .set VE_HEAD = VE_INTERPRET XT_INTERPRET: 000617 3800 .dw DO_COLON .endif PFA_INTERPRET: 000618 05a2 .dw XT_PARSENAME ; ( -- addr len ) 000619 38b0 .dw XT_DUP ; ( -- addr len flag) 00061a 3835 .dw XT_DOCONDBRANCH 00061b 0628 DEST(PFA_INTERPRET2) 00061c 05e5 .dw XT_FORTHRECOGNIZER 00061d 05f0 .dw XT_RECOGNIZE 00061e 3eb6 .dw XT_STATE 00061f 3878 .dw XT_FETCH 000620 3835 .dw XT_DOCONDBRANCH 000621 0623 DEST(PFA_INTERPRET1) 000622 01a7 .dw XT_ICELLPLUS ; we need the compile action PFA_INTERPRET1: 000623 3bca .dw XT_FETCHI 000624 3829 .dw XT_EXECUTE 000625 3f8a .dw XT_QSTACK 000626 382e .dw XT_DOBRANCH 000627 0618 DEST(PFA_INTERPRET) PFA_INTERPRET2: 000628 3ed1 .dw XT_2DROP 000629 381f .dw XT_EXIT .include "words/rec-intnum.asm" ; Interpreter ; Method table for single cell integers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DT_NUM: 00062a ff06 .dw $ff06 00062b 7464 00062c 6e3a 00062d 6d75 .db "dt:num" 00062e 0610 .dw VE_HEAD .set VE_HEAD = VE_DT_NUM XT_DT_NUM: 00062f 3851 .dw PFA_DOCONSTANT PFA_DT_NUM: .endif 000630 017b .dw XT_NOOP ; interpret 000631 0764 .dw XT_LITERAL ; compile 000632 0764 .dw XT_LITERAL ; postpone ; ( -- addr ) ; Interpreter ; Method table for double cell integers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DT_DNUM: 000633 ff07 .dw $ff07 000634 7464 000635 643a 000636 756e 000637 006d .db "dt:dnum",0 000638 062a .dw VE_HEAD .set VE_HEAD = VE_DT_DNUM XT_DT_DNUM: 000639 3851 .dw PFA_DOCONSTANT PFA_DT_DNUM: .endif 00063a 017b .dw XT_NOOP ; interpret 00063b 3fd6 .dw XT_2LITERAL ; compile 00063c 3fd6 .dw XT_2LITERAL ; postpone ; ( addr len -- f ) ; Interpreter ; recognizer for integer numbers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_REC_NUM: 00063d ff07 .dw $ff07 00063e 6572 00063f 3a63 000640 756e 000641 006d .db "rec:num",0 000642 0633 .dw VE_HEAD .set VE_HEAD = VE_REC_NUM XT_REC_NUM: 000643 3800 .dw DO_COLON PFA_REC_NUM: .endif ; try converting to a number 000644 04e2 .dw XT_NUMBER 000645 3835 .dw XT_DOCONDBRANCH 000646 064f DEST(PFA_REC_NONUMBER) 000647 3fe5 .dw XT_ONE 000648 3fde .dw XT_EQUAL 000649 3835 .dw XT_DOCONDBRANCH 00064a 064d DEST(PFA_REC_INTNUM2) 00064b 062f .dw XT_DT_NUM 00064c 381f .dw XT_EXIT PFA_REC_INTNUM2: 00064d 0639 .dw XT_DT_DNUM 00064e 381f .dw XT_EXIT PFA_REC_NONUMBER: 00064f 067d .dw XT_DT_NULL 000650 381f .dw XT_EXIT .include "words/rec-find.asm" ; Interpreter ; search for a word .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_REC_FIND: 000651 ff08 .dw $ff08 000652 6572 000653 3a63 000654 6966 000655 646e .db "rec:find" 000656 063d .dw VE_HEAD .set VE_HEAD = VE_REC_FIND XT_REC_FIND: 000657 3800 .dw DO_COLON PFA_REC_FIND: .endif 000658 06f2 .DW XT_FINDXT 000659 38b0 .dw XT_DUP 00065a 3919 .dw XT_ZEROEQUAL 00065b 3835 .dw XT_DOCONDBRANCH 00065c 0660 DEST(PFA_REC_WORD_FOUND) 00065d 38d8 .dw XT_DROP 00065e 067d .dw XT_DT_NULL 00065f 381f .dw XT_EXIT PFA_REC_WORD_FOUND: 000660 0667 .dw XT_DT_XT 000661 381f .dw XT_EXIT ; ( -- addr ) ; Interpreter ; actions to handle execution tokens and their flags .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DT_XT: 000662 ff05 .dw $ff05 000663 7464 000664 783a 000665 0074 .db "dt:xt",0 000666 0651 .dw VE_HEAD .set VE_HEAD = VE_DT_XT XT_DT_XT: 000667 3851 .dw PFA_DOCONSTANT PFA_DT_XT: .endif 000668 066b .dw XT_R_WORD_INTERPRET 000669 066f .dw XT_R_WORD_COMPILE 00066a 3fd6 .dw XT_2LITERAL ; ( XT flags -- ) ; Interpreter ; interpret method for WORD recognizer .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_R_WORD_INTERPRET: 00066b 3800 .dw DO_COLON PFA_R_WORD_INTERPRET: .endif 00066c 38d8 .dw XT_DROP ; the flags are in the way 00066d 3829 .dw XT_EXECUTE 00066e 381f .dw XT_EXIT ; ( XT flags -- ) ; Interpreter ; Compile method for WORD recognizer .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_R_WORD_COMPILE: 00066f 3800 .dw DO_COLON PFA_R_WORD_COMPILE: .endif 000670 3920 .dw XT_ZEROLESS 000671 3835 .dw XT_DOCONDBRANCH 000672 0675 DEST(PFA_R_WORD_COMPILE1) 000673 074e .dw XT_COMMA 000674 381f .dw XT_EXIT PFA_R_WORD_COMPILE1: 000675 3829 .dw XT_EXECUTE 000676 381f .dw XT_EXIT .include "words/dt-null.asm" ; Interpreter ; there is no parser for this recognizer, this is the default and failsafe part .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DT_NULL: 000677 ff07 .dw $ff07 000678 7464 000679 6e3a 00067a 6c75 ../../common\words/dt-null.asm(12): warning: .cseg .db misalignment - padding zero byte 00067b 006c .db "dt:null" 00067c 0662 .dw VE_HEAD .set VE_HEAD = VE_DT_NULL XT_DT_NULL: 00067d 3851 .dw PFA_DOCONSTANT PFA_DT_NULL: .endif 00067e 0681 .dw XT_FAIL ; interpret 00067f 0681 .dw XT_FAIL ; compile 000680 0681 .dw XT_FAIL ; postpone ; ( addr len -- ) ; Interpreter ; default failure action: throw exception -13. .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_FAIL: ; .dw $ff04 ; .db "fail" ; .dw VE_HEAD ; .set VE_HEAD = VE_FAIL XT_FAIL: 000681 3800 .dw DO_COLON PFA_FAIL: .endif 000682 383c .dw XT_DOLITERAL 000683 fff3 .dw -13 000684 3d85 .dw XT_THROW .include "words/search-wordlist.asm" ; Search Order ; searches the word list wid for the word at c-addr/len .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SEARCH_WORDLIST: 000685 ff0f .dw $ff0f 000686 6573 000687 7261 000688 6863 000689 772d 00068a 726f 00068b 6c64 00068c 7369 00068d 0074 .db "search-wordlist",0 00068e 0677 .dw VE_HEAD .set VE_HEAD = VE_SEARCH_WORDLIST XT_SEARCH_WORDLIST: 00068f 3800 .dw DO_COLON PFA_SEARCH_WORDLIST: .endif 000690 38fe .dw XT_TO_R 000691 3953 .dw XT_ZERO 000692 383c .dw XT_DOLITERAL 000693 06a4 .dw XT_ISWORD 000694 38f5 .dw XT_R_FROM 000695 06c1 .dw XT_TRAVERSEWORDLIST 000696 38b0 .dw XT_DUP 000697 3919 .dw XT_ZEROEQUAL 000698 3835 .dw XT_DOCONDBRANCH 000699 069e DEST(PFA_SEARCH_WORDLIST1) 00069a 3ed1 .dw XT_2DROP 00069b 38d8 .dw XT_DROP 00069c 3953 .dw XT_ZERO 00069d 381f .dw XT_EXIT PFA_SEARCH_WORDLIST1: ; ... get the XT ... 00069e 38b0 .dw XT_DUP 00069f 06e8 .dw XT_NFA2CFA ; .. and get the header flag 0006a0 38c3 .dw XT_SWAP 0006a1 0156 .dw XT_NAME2FLAGS 0006a2 0144 .dw XT_IMMEDIATEQ 0006a3 381f .dw XT_EXIT .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_ISWORD: 0006a4 3800 .dw DO_COLON PFA_ISWORD: .endif ; ( c-addr len 0 nt -- c-addr len 0 true| nt false ) 0006a5 38fe .dw XT_TO_R 0006a6 38d8 .dw XT_DROP 0006a7 3ec8 .dw XT_2DUP 0006a8 3907 .dw XT_R_FETCH ; -- addr len addr len nt 0006a9 06dc .dw XT_NAME2STRING 0006aa 01b0 .dw XT_ICOMPARE ; (-- addr len f ) 0006ab 3835 .dw XT_DOCONDBRANCH 0006ac 06b2 DEST(PFA_ISWORD3) ; not now 0006ad 38f5 .dw XT_R_FROM 0006ae 38d8 .dw XT_DROP 0006af 3953 .dw XT_ZERO 0006b0 394a .dw XT_TRUE ; maybe next word 0006b1 381f .dw XT_EXIT PFA_ISWORD3: ; we found the word, now clean up iteration data ... 0006b2 3ed1 .dw XT_2DROP 0006b3 38f5 .dw XT_R_FROM 0006b4 3953 .dw XT_ZERO ; finish traverse-wordlist 0006b5 381f .dw XT_EXIT .include "words/traverse-wordlist.asm" ; Tools Ext (2012) ; call the xt for every member of the wordlist wid until xt returns false .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TRAVERSEWORDLIST: 0006b6 ff11 .dw $ff11 0006b7 7274 0006b8 7661 0006b9 7265 0006ba 6573 0006bb 772d 0006bc 726f 0006bd 6c64 0006be 7369 0006bf 0074 .db "traverse-wordlist",0 0006c0 0685 .dw VE_HEAD .set VE_HEAD = VE_TRAVERSEWORDLIST XT_TRAVERSEWORDLIST: 0006c1 3800 .dw DO_COLON PFA_TRAVERSEWORDLIST: .endif 0006c2 3b5e .dw XT_FETCHE PFA_TRAVERSEWORDLIST1: 0006c3 38b0 .dw XT_DUP ; ( -- xt nt nt ) 0006c4 3835 .dw XT_DOCONDBRANCH ; ( -- nt ) is nfa = counted string 0006c5 06d2 DEST(PFA_TRAVERSEWORDLIST2) 0006c6 3ec8 .dw XT_2DUP 0006c7 3b1d .dw XT_2TO_R 0006c8 38c3 .dw XT_SWAP 0006c9 3829 .dw XT_EXECUTE 0006ca 3b2c .dw XT_2R_FROM 0006cb 38e0 .dw XT_ROT 0006cc 3835 .dw XT_DOCONDBRANCH 0006cd 06d2 DEST(PFA_TRAVERSEWORDLIST2) 0006ce 09fd .dw XT_NFA2LFA 0006cf 3bca .dw XT_FETCHI 0006d0 382e .dw XT_DOBRANCH ; ( -- addr ) 0006d1 06c3 DEST(PFA_TRAVERSEWORDLIST1) ; ( -- addr ) PFA_TRAVERSEWORDLIST2: 0006d2 3ed1 .dw XT_2DROP 0006d3 381f .dw XT_EXIT ; : traverse-wordlist ( i*x xt wid -- i*x' ) ; begin @ dup ; while ; 2dup 2>r ; swap execute ( i*x nt -- i*x' f ) ; 2r> rot ; while ; nfa>lfa @i ; repeat then 2drop ; .include "words/name2string.asm" ; Tools Ext (2012) ; get a (flash) string from a name token nt .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_NAME2STRING: 0006d4 ff0b .dw $ff0b 0006d5 616e 0006d6 656d 0006d7 733e 0006d8 7274 0006d9 6e69 0006da 0067 .db "name>string",0 0006db 06b6 .dw VE_HEAD .set VE_HEAD = VE_NAME2STRING XT_NAME2STRING: 0006dc 3800 .dw DO_COLON PFA_NAME2STRING: .endif 0006dd 0416 .dw XT_ICOUNT ; ( -- addr n ) 0006de 383c .dw XT_DOLITERAL 0006df 00ff .dw 255 0006e0 3a12 .dw XT_AND ; mask immediate bit 0006e1 381f .dw XT_EXIT .include "words/nfa2cfa.asm" ; Tools ; get the XT from a name token VE_NFA2CFA: 0006e2 ff07 .dw $ff07 0006e3 666e 0006e4 3e61 0006e5 6663 ../../avr8\words/nfa2cfa.asm(6): warning: .cseg .db misalignment - padding zero byte 0006e6 0061 .db "nfa>cfa" 0006e7 06d4 .dw VE_HEAD .set VE_HEAD = VE_NFA2CFA XT_NFA2CFA: 0006e8 3800 .dw DO_COLON PFA_NFA2CFA: 0006e9 09fd .dw XT_NFA2LFA ; skip to link field 0006ea 3a2e .dw XT_1PLUS ; next is the execution token 0006eb 381f .dw XT_EXIT .include "words/find-xt.asm" ; Tools ; search wordlists for an entry with the xt from c-addr/len .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_FINDXT: 0006ec ff07 .dw $ff07 0006ed 6966 0006ee 646e 0006ef 782d 0006f0 0074 .db "find-xt",0 0006f1 06e2 .dw VE_HEAD .set VE_HEAD = VE_FINDXT XT_FINDXT: 0006f2 3800 .dw DO_COLON PFA_FINDXT: .endif 0006f3 383c .dw XT_DOLITERAL 0006f4 06fe .dw XT_FINDXTA 0006f5 383c .dw XT_DOLITERAL 0006f6 006c .dw CFG_ORDERLISTLEN 0006f7 098e .dw XT_MAPSTACK 0006f8 3919 .dw XT_ZEROEQUAL 0006f9 3835 .dw XT_DOCONDBRANCH 0006fa 06fd DEST(PFA_FINDXT1) 0006fb 3ed1 .dw XT_2DROP 0006fc 3953 .dw XT_ZERO PFA_FINDXT1: 0006fd 381f .dw XT_EXIT .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_FINDXTA: 0006fe 3800 .dw DO_COLON PFA_FINDXTA: .endif 0006ff 38fe .dw XT_TO_R 000700 3ec8 .dw XT_2DUP 000701 38f5 .dw XT_R_FROM 000702 068f .dw XT_SEARCH_WORDLIST 000703 38b0 .dw XT_DUP 000704 3835 .dw XT_DOCONDBRANCH 000705 070b DEST(PFA_FINDXTA1) 000706 38fe .dw XT_TO_R 000707 38ef .dw XT_NIP 000708 38ef .dw XT_NIP 000709 38f5 .dw XT_R_FROM 00070a 394a .dw XT_TRUE PFA_FINDXTA1: 00070b 381f .dw XT_EXIT .include "dict/compiler1.inc" .include "words/newest.asm" ; System Variable ; system state VE_NEWEST: 00070c ff06 .dw $ff06 00070d 656e 00070e 6577 00070f 7473 .db "newest" 000710 06ec .dw VE_HEAD .set VE_HEAD = VE_NEWEST XT_NEWEST: 000711 3847 .dw PFA_DOVARIABLE PFA_NEWEST: 000712 019b .dw ram_newest .dseg 00019b ram_newest: .byte 4 .include "words/latest.asm" ; System Variable ; system state VE_LATEST: 000713 ff06 .dw $ff06 000714 616c 000715 6574 000716 7473 .db "latest" 000717 070c .dw VE_HEAD .set VE_HEAD = VE_LATEST XT_LATEST: 000718 3847 .dw PFA_DOVARIABLE PFA_LATEST: 000719 019f .dw ram_latest .dseg 00019f ram_latest: .byte 2 .include "words/do-create.asm" ; Compiler ; parse the input and create an empty vocabulary entry without XT and data field (PF) .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DOCREATE: 00071a ff08 .dw $ff08 00071b 6328 00071c 6572 00071d 7461 00071e 2965 .db "(create)" 00071f 0713 .dw VE_HEAD .set VE_HEAD = VE_DOCREATE XT_DOCREATE: 000720 3800 .dw DO_COLON PFA_DOCREATE: .endif 000721 05a2 000722 0877 .DW XT_PARSENAME,XT_WLSCOPE ; ( -- addr len wid) 000723 38b0 000724 0711 000725 3c8f 000726 3880 .DW XT_DUP,XT_NEWEST,XT_CELLPLUS,XT_STORE ; save the wid 000727 085c 000728 0711 000729 3880 .DW XT_HEADER,XT_NEWEST,XT_STORE ; save the nt 00072a 381f .DW XT_EXIT .include "words/backslash.asm" ; Compiler ; everything up to the end of the current line is a comment .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BACKSLASH: 00072b 0001 .dw $0001 00072c 005c .db $5c,0 00072d 071a .dw VE_HEAD .set VE_HEAD = VE_BACKSLASH XT_BACKSLASH: 00072e 3800 .dw DO_COLON PFA_BACKSLASH: .endif 00072f 0589 .dw XT_SOURCE 000730 38ef .dw XT_NIP 000731 3ee1 .dw XT_TO_IN 000732 3880 .dw XT_STORE 000733 381f .dw XT_EXIT .include "words/l-paren.asm" ; Compiler ; skip everything up to the closing bracket on the same line .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_LPAREN: 000734 0001 .dw $0001 000735 0028 .db "(" ,0 000736 072b .dw VE_HEAD .set VE_HEAD = VE_LPAREN XT_LPAREN: 000737 3800 .dw DO_COLON PFA_LPAREN: .endif 000738 383c .dw XT_DOLITERAL 000739 0029 .dw ')' 00073a 0575 .dw XT_PARSE 00073b 3ed1 .dw XT_2DROP 00073c 381f .dw XT_EXIT .include "words/compile.asm" ; Dictionary ; read the following cell from the dictionary and append it to the current dictionary position. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_COMPILE: 00073d ff07 .dw $ff07 00073e 6f63 00073f 706d 000740 6c69 000741 0065 .db "compile",0 000742 0734 .dw VE_HEAD .set VE_HEAD = VE_COMPILE XT_COMPILE: 000743 3800 .dw DO_COLON PFA_COMPILE: .endif 000744 38f5 .dw XT_R_FROM 000745 38b0 .dw XT_DUP 000746 01a7 .dw XT_ICELLPLUS 000747 38fe .dw XT_TO_R 000748 3bca .dw XT_FETCHI 000749 074e .dw XT_COMMA 00074a 381f .dw XT_EXIT .include "words/comma.asm" ; Dictionary ; compile 16 bit into flash at DP VE_COMMA: 00074b ff01 .dw $ff01 00074c 002c .db ',',0 ; , 00074d 073d .dw VE_HEAD .set VE_HEAD = VE_COMMA XT_COMMA: 00074e 3800 .dw DO_COLON PFA_COMMA: 00074f 3f11 .dw XT_DP 000750 3b72 .dw XT_STOREI 000751 3f11 .dw XT_DP 000752 3a2e .dw XT_1PLUS 000753 0195 .dw XT_DOTO 000754 3f12 .dw PFA_DP 000755 381f .dw XT_EXIT .include "words/brackettick.asm" ; Compiler ; what ' does in the interpreter mode, do in colon definitions .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BRACKETTICK: 000756 0003 .dw $0003 000757 275b 000758 005d .db "[']",0 000759 074b .dw VE_HEAD .set VE_HEAD = VE_BRACKETTICK XT_BRACKETTICK: 00075a 3800 .dw DO_COLON PFA_BRACKETTICK: .endif 00075b 042f .dw XT_TICK 00075c 0764 .dw XT_LITERAL 00075d 381f .dw XT_EXIT .include "words/literal.asm" ; Compiler ; compile a literal in colon defintions .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_LITERAL: 00075e 0007 .dw $0007 00075f 696c 000760 6574 000761 6172 000762 006c .db "literal",0 000763 0756 .dw VE_HEAD .set VE_HEAD = VE_LITERAL XT_LITERAL: 000764 3800 .dw DO_COLON PFA_LITERAL: .endif 000765 0743 .DW XT_COMPILE 000766 383c .DW XT_DOLITERAL 000767 074e .DW XT_COMMA 000768 381f .DW XT_EXIT .include "words/sliteral.asm" ; String ; compiles a string to flash, at runtime leaves ( -- flash-addr count) on stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SLITERAL: 000769 0008 .dw $0008 00076a 6c73 00076b 7469 00076c 7265 00076d 6c61 .db "sliteral" 00076e 075e .dw VE_HEAD .set VE_HEAD = VE_SLITERAL XT_SLITERAL: 00076f 3800 .dw DO_COLON PFA_SLITERAL: .endif 000770 0743 .dw XT_COMPILE 000771 03b7 .dw XT_DOSLITERAL ; ( -- addr n) 000772 03c5 .dw XT_SCOMMA 000773 381f .dw XT_EXIT .include "words/g-mark.asm" ; Compiler ; places current dictionary position for backward resolves ;VE_GMARK: ; .dw $ff05 ; .db ">mark" ; .dw VE_HEAD ; .set VE_HEAD = VE_GMARK XT_GMARK: 000774 3800 .dw DO_COLON PFA_GMARK: 000775 3f11 .dw XT_DP 000776 0743 .dw XT_COMPILE 000777 ffff .dw -1 ; ffff does not erase flash 000778 381f .dw XT_EXIT .include "words/g-resolve.asm" ; Compiler ; resolve backward jumps ;VE_GRESOLVE: ; .dw $ff08 ; .db ">resolve" ; .dw VE_HEAD ; .set VE_HEAD = VE_GRESOLVE XT_GRESOLVE: 000779 3800 .dw DO_COLON PFA_GRESOLVE: 00077a 3f8a .dw XT_QSTACK 00077b 3f11 .dw XT_DP 00077c 38c3 .dw XT_SWAP 00077d 3b72 .dw XT_STOREI 00077e 381f .dw XT_EXIT .include "words/l_mark.asm" ; Compiler ; place destination for backward branch ;VE_LMARK: ; .dw $ff05 ; .db "r if 2drop then r> invert ; .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_QDOCHECK: 00080d 3800 .dw DO_COLON PFA_QDOCHECK: .endif 00080e 3ec8 .dw XT_2DUP 00080f 3fde .dw XT_EQUAL 000810 38b0 .dw XT_DUP 000811 38fe .dw XT_TO_R 000812 3835 .dw XT_DOCONDBRANCH 000813 0815 DEST(PFA_QDOCHECK1) 000814 3ed1 .dw XT_2DROP PFA_QDOCHECK1: 000815 38f5 .dw XT_R_FROM 000816 39fc .dw XT_INVERT 000817 381f .dw XT_EXIT .include "words/endloop.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ENDLOOP: 000818 ff07 .dw $ff07 000819 6e65 00081a 6c64 00081b 6f6f 00081c 0070 .db "endloop",0 00081d 0801 .dw VE_HEAD .set VE_HEAD = VE_ENDLOOP XT_ENDLOOP: 00081e 3800 .dw DO_COLON PFA_ENDLOOP: .endif ;Z ENDLOOP adrs xt -- L: 0 a1 a2 .. aN -- ; ?DUP WHILE POSTPONE THEN REPEAT ; ; resolve LEAVEs ; This is a common factor of LOOP and +LOOP. 00081f 0782 .DW XT_LRESOLVE 000820 082b 000821 38b8 000822 3835 LOOP1: .DW XT_L_FROM,XT_QDUP,XT_DOCONDBRANCH 000823 0827 DEST(LOOP2) 000824 07a7 .DW XT_THEN 000825 382e .dw XT_DOBRANCH 000826 0820 DEST(LOOP1) 000827 381f LOOP2: .DW XT_EXIT ; leave address stack .include "words/l-from.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_L_FROM: 000828 ff02 .dw $ff02 000829 3e6c .db "l>" 00082a 0818 .dw VE_HEAD .set VE_HEAD = VE_L_FROM XT_L_FROM: 00082b 3800 .dw DO_COLON PFA_L_FROM: .endif ;Z L> -- x L: x -- move from leave stack ; LP @ @ -2 LP +! ; 00082c 084a .dw XT_LP 00082d 3878 .dw XT_FETCH 00082e 3878 .dw XT_FETCH 00082f 383c .dw XT_DOLITERAL 000830 fffe .dw -2 000831 084a .dw XT_LP 000832 3a64 .dw XT_PLUSSTORE 000833 381f .dw XT_EXIT .include "words/to-l.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TO_L: 000834 ff02 .dw $ff02 000835 6c3e .db ">l" 000836 0828 .dw VE_HEAD .set VE_HEAD = VE_TO_L XT_TO_L: 000837 3800 .dw DO_COLON PFA_TO_L: .endif ;Z >L x -- L: -- x move to leave stack ; CELL LP +! LP @ ! ; (L stack grows up) 000838 3fea .dw XT_TWO 000839 084a .dw XT_LP 00083a 3a64 .dw XT_PLUSSTORE 00083b 084a .dw XT_LP 00083c 3878 .dw XT_FETCH 00083d 3880 .dw XT_STORE 00083e 381f .dw XT_EXIT .include "words/lp0.asm" ; Stack ; start address of leave stack VE_LP0: 00083f ff03 .dw $ff03 000840 706c 000841 0030 .db "lp0",0 000842 0834 .dw VE_HEAD .set VE_HEAD = VE_LP0 XT_LP0: 000843 386e .dw PFA_DOVALUE1 PFA_LP0: 000844 0062 .dw CFG_LP0 000845 3d9f .dw XT_EDEFERFETCH 000846 3da9 .dw XT_EDEFERSTORE .include "words/lp.asm" ; System Variable ; leave stack pointer VE_LP: 000847 ff02 .dw $ff02 000848 706c .db "lp" 000849 083f .dw VE_HEAD .set VE_HEAD = VE_LP XT_LP: 00084a 3847 .dw PFA_DOVARIABLE PFA_LP: 00084b 01a1 .dw ram_lp .dseg 0001a1 ram_lp: .byte 2 .cseg .include "words/create.asm" ; Dictionary ; create a dictionary header. XT is (constant), with the address of the data field of name .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CREATE: 00084c ff06 .dw $ff06 00084d 7263 00084e 6165 00084f 6574 .db "create" 000850 0847 .dw VE_HEAD .set VE_HEAD = VE_CREATE XT_CREATE: 000851 3800 .dw DO_COLON PFA_CREATE: .endif 000852 0720 .dw XT_DOCREATE 000853 0880 .dw XT_REVEAL 000854 0743 .dw XT_COMPILE 000855 3851 .dw PFA_DOCONSTANT 000856 381f .dw XT_EXIT .include "words/header.asm" ; Compiler ; creates the vocabulary header without XT and data field (PF) in the wordlist wid VE_HEADER: 000857 ff06 .dw $ff06 000858 6568 000859 6461 00085a 7265 .db "header" 00085b 084c .dw VE_HEAD .set VE_HEAD = VE_HEADER XT_HEADER: 00085c 3800 .dw DO_COLON PFA_HEADER: 00085d 3f11 .dw XT_DP ; the new Name Field 00085e 38fe .dw XT_TO_R 00085f 38fe .dw XT_TO_R ; ( R: NFA WID ) 000860 38b0 .dw XT_DUP 000861 3927 .dw XT_GREATERZERO 000862 3835 .dw XT_DOCONDBRANCH 000863 086e .dw PFA_HEADER1 000864 38b0 .dw XT_DUP 000865 383c .dw XT_DOLITERAL 000866 ff00 .dw $ff00 ; all flags are off (e.g. immediate) 000867 3a1b .dw XT_OR 000868 03c9 .dw XT_DOSCOMMA ; make the link to the previous entry in this wordlist 000869 38f5 .dw XT_R_FROM 00086a 3b5e .dw XT_FETCHE 00086b 074e .dw XT_COMMA 00086c 38f5 .dw XT_R_FROM 00086d 381f .dw XT_EXIT PFA_HEADER1: ; -16: attempt to use zero length string as a name 00086e 383c .dw XT_DOLITERAL 00086f fff0 .dw -16 000870 3d85 .dw XT_THROW .include "words/wlscope.asm" ; Compiler ; dynamically place a word in a wordlist. The word name may be changed. VE_WLSCOPE: 000871 ff07 .dw $ff07 000872 6c77 000873 6373 000874 706f 000875 0065 .db "wlscope",0 000876 0857 .dw VE_HEAD .set VE_HEAD = VE_WLSCOPE XT_WLSCOPE: 000877 3dfe .dw PFA_DODEFER1 PFA_WLSCOPE: 000878 005e .dw CFG_WLSCOPE 000879 3d9f .dw XT_EDEFERFETCH 00087a 3da9 .dw XT_EDEFERSTORE ; wlscope, "wordlist scope" ( addr len -- addr' len' wid ), is a deferred word ; which enables the AmForth application to choose the wordlist ( wid ) for the ; new voc entry based on the input ( addr len ) string. The name of the new voc ; entry ( addr' len' ) may be different from the input string. Note that all ; created voc entry types pass through the wlscope mechanism. The default ; wlscope action passes the input string to the output without modification and ; uses get-current to select the wid. .include "words/reveal.asm" ; Dictionary ; makes an entry in a wordlist visible, if not already done. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_REVEAL: 00087b ff06 .dw $ff06 00087c 6572 00087d 6576 00087e 6c61 .db "reveal" 00087f 0871 .dw VE_HEAD .set VE_HEAD = VE_REVEAL XT_REVEAL: 000880 3800 .dw DO_COLON PFA_REVEAL: .endif 000881 0711 000882 3c8f 000883 3878 .DW XT_NEWEST,XT_CELLPLUS,XT_FETCH ; only if wordlist is in use 000884 38b8 000885 3835 .DW XT_QDUP,XT_DOCONDBRANCH 000886 088b DEST(REVEAL1) 000887 0711 000888 3878 000889 38c3 00088a 3b3a .DW XT_NEWEST,XT_FETCH,XT_SWAP,XT_STOREE ; .DW XT_ZERO,XT_NEWEST,XT_CELLPLUS,XT_STORE ; clean wordlist entry REVEAL1: 00088b 381f .DW XT_EXIT .include "words/does.asm" ; Compiler ; organize the XT replacement to call other colon code VE_DOES: 00088c 0005 .dw $0005 00088d 6f64 00088e 7365 00088f 003e .db "does>",0 000890 087b .dw VE_HEAD .set VE_HEAD = VE_DOES XT_DOES: 000891 3800 .dw DO_COLON PFA_DOES: 000892 0743 .dw XT_COMPILE 000893 08a4 .dw XT_DODOES 000894 0743 .dw XT_COMPILE ; create a code snippet to be used in an embedded XT 000895 940e .dw $940e ; the address of this compiled 000896 0743 .dw XT_COMPILE ; code will replace the XT of the 000897 0899 .dw DO_DODOES ; word that CREATE created 000898 381f .dw XT_EXIT ; DO_DODOES: ; ( -- PFA ) 000899 939a 00089a 938a savetos 00089b 01cb movw tosl, wl 00089c 9601 adiw tosl, 1 ; the following takes the address from a real uC-call .if (pclen==3) .endif 00089d 917f pop wh 00089e 916f pop wl 00089f 93bf push XH 0008a0 93af push XL 0008a1 01db movw XL, wl 0008a2 940c 3804 jmp_ DO_NEXT ; ( -- ) ; System ; replace the XT written by CREATE to call the code that follows does> ;VE_DODOES: ; .dw $ff07 ; .db "(does>)" ; .set VE_HEAD = VE_DODOES XT_DODOES: 0008a4 3800 .dw DO_COLON PFA_DODOES: 0008a5 38f5 .dw XT_R_FROM 0008a6 0711 .dw XT_NEWEST 0008a7 3c8f .dw XT_CELLPLUS 0008a8 3878 .dw XT_FETCH 0008a9 3b5e .dw XT_FETCHE 0008aa 06e8 .dw XT_NFA2CFA 0008ab 3b72 .dw XT_STOREI 0008ac 381f .dw XT_EXIT .include "words/colon.asm" ; Compiler ; create a named entry in the dictionary, XT is DO_COLON .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_COLON: 0008ad ff01 .dw $ff01 0008ae 003a .db ":",0 0008af 088c .dw VE_HEAD .set VE_HEAD = VE_COLON XT_COLON: 0008b0 3800 .dw DO_COLON PFA_COLON: .endif 0008b1 0720 .dw XT_DOCREATE 0008b2 08bb .dw XT_COLONNONAME 0008b3 38d8 .dw XT_DROP 0008b4 381f .dw XT_EXIT .include "words/colon-noname.asm" ; Compiler ; create an unnamed entry in the dictionary, XT is DO_COLON VE_COLONNONAME: 0008b5 ff07 .dw $ff07 0008b6 6e3a 0008b7 6e6f 0008b8 6d61 0008b9 0065 .db ":noname",0 0008ba 08ad .dw VE_HEAD .set VE_HEAD = VE_COLONNONAME XT_COLONNONAME: 0008bb 3800 .dw DO_COLON PFA_COLONNONAME: 0008bc 3f11 .dw XT_DP 0008bd 38b0 .dw XT_DUP 0008be 0718 .dw XT_LATEST 0008bf 3880 .dw XT_STORE 0008c0 0743 .dw XT_COMPILE 0008c1 3800 .dw DO_COLON 0008c2 08d0 .dw XT_RBRACKET 0008c3 381f .dw XT_EXIT .include "words/semicolon.asm" ; Compiler ; finish colon defintion, compiles (exit) and returns to interpret state .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SEMICOLON: 0008c4 0001 .dw $0001 0008c5 003b .db $3b,0 0008c6 08b5 .dw VE_HEAD .set VE_HEAD = VE_SEMICOLON XT_SEMICOLON: 0008c7 3800 .dw DO_COLON PFA_SEMICOLON: .endif 0008c8 0743 .dw XT_COMPILE 0008c9 381f .dw XT_EXIT 0008ca 08d8 .dw XT_LBRACKET 0008cb 0880 .dw XT_REVEAL 0008cc 381f .dw XT_EXIT .include "words/right-bracket.asm" ; Compiler ; enter compiler mode .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_RBRACKET: 0008cd ff01 .dw $ff01 0008ce 005d .db "]",0 0008cf 08c4 .dw VE_HEAD .set VE_HEAD = VE_RBRACKET XT_RBRACKET: 0008d0 3800 .dw DO_COLON PFA_RBRACKET: .endif 0008d1 3fe5 .dw XT_ONE 0008d2 3eb6 .dw XT_STATE 0008d3 3880 .dw XT_STORE 0008d4 381f .dw XT_EXIT .include "words/left-bracket.asm" ; Compiler ; enter interpreter mode .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_LBRACKET: 0008d5 0001 .dw $0001 0008d6 005b .db "[",0 0008d7 08cd .dw VE_HEAD .set VE_HEAD = VE_LBRACKET XT_LBRACKET: 0008d8 3800 .dw DO_COLON PFA_LBRACKET: .endif 0008d9 3953 .dw XT_ZERO 0008da 3eb6 .dw XT_STATE 0008db 3880 .dw XT_STORE 0008dc 381f .dw XT_EXIT .include "words/variable.asm" ; Compiler ; create a dictionary entry for a variable and allocate 1 cell RAM .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_VARIABLE: 0008dd ff08 .dw $ff08 0008de 6176 0008df 6972 0008e0 6261 0008e1 656c .db "variable" 0008e2 08d5 .dw VE_HEAD .set VE_HEAD = VE_VARIABLE XT_VARIABLE: 0008e3 3800 .dw DO_COLON PFA_VARIABLE: .endif 0008e4 3f22 .dw XT_HERE 0008e5 08ef .dw XT_CONSTANT 0008e6 3fea .dw XT_TWO 0008e7 3f2b .dw XT_ALLOT 0008e8 381f .dw XT_EXIT .include "words/constant.asm" ; Compiler ; create a constant in the dictionary .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CONSTANT: 0008e9 ff08 .dw $ff08 0008ea 6f63 0008eb 736e 0008ec 6174 0008ed 746e .db "constant" 0008ee 08dd .dw VE_HEAD .set VE_HEAD = VE_CONSTANT XT_CONSTANT: 0008ef 3800 .dw DO_COLON PFA_CONSTANT: .endif 0008f0 0720 .dw XT_DOCREATE 0008f1 0880 .dw XT_REVEAL 0008f2 0743 .dw XT_COMPILE 0008f3 3847 .dw PFA_DOVARIABLE 0008f4 074e .dw XT_COMMA 0008f5 381f .dw XT_EXIT .include "words/user.asm" ; Compiler ; create a dictionary entry for a user variable at offset n VE_USER: 0008f6 ff04 .dw $ff04 0008f7 7375 0008f8 7265 .db "user" 0008f9 08e9 .dw VE_HEAD .set VE_HEAD = VE_USER XT_USER: 0008fa 3800 .dw DO_COLON PFA_USER: 0008fb 0720 .dw XT_DOCREATE 0008fc 0880 .dw XT_REVEAL 0008fd 0743 .dw XT_COMPILE 0008fe 3857 .dw PFA_DOUSER 0008ff 074e .dw XT_COMMA 000900 381f .dw XT_EXIT .include "words/recurse.asm" ; Compiler ; compile the XT of the word currently being defined into the dictionary .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_RECURSE: 000901 0007 .dw $0007 000902 6572 000903 7563 000904 7372 000905 0065 .db "recurse",0 000906 08f6 .dw VE_HEAD .set VE_HEAD = VE_RECURSE XT_RECURSE: 000907 3800 .dw DO_COLON PFA_RECURSE: .endif 000908 0718 .dw XT_LATEST 000909 3878 .dw XT_FETCH 00090a 074e .dw XT_COMMA 00090b 381f .dw XT_EXIT .include "words/immediate.asm" ; Compiler ; set immediate flag for the most recent word definition VE_IMMEDIATE: 00090c ff09 .dw $ff09 00090d 6d69 00090e 656d 00090f 6964 000910 7461 000911 0065 .db "immediate",0 000912 0901 .dw VE_HEAD .set VE_HEAD = VE_IMMEDIATE XT_IMMEDIATE: 000913 3800 .dw DO_COLON PFA_IMMEDIATE: 000914 09b5 .dw XT_GET_CURRENT 000915 3b5e .dw XT_FETCHE 000916 38b0 .dw XT_DUP 000917 3bca .dw XT_FETCHI 000918 383c .dw XT_DOLITERAL 000919 7fff .dw $7fff 00091a 3a12 .dw XT_AND 00091b 38c3 .dw XT_SWAP 00091c 3b72 .dw XT_STOREI 00091d 381f .dw XT_EXIT .include "words/bracketchar.asm" ; Tools ; skip leading space delimites, place the first character of the word on the stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BRACKETCHAR: 00091e 0006 .dw $0006 00091f 635b 000920 6168 000921 5d72 .db "[char]" 000922 090c .dw VE_HEAD .set VE_HEAD = VE_BRACKETCHAR XT_BRACKETCHAR: 000923 3800 .dw DO_COLON PFA_BRACKETCHAR: .endif 000924 0743 .dw XT_COMPILE 000925 383c .dw XT_DOLITERAL 000926 04d8 .dw XT_CHAR 000927 074e .dw XT_COMMA 000928 381f .dw XT_EXIT .include "words/abort-string.asm" ;C i*x x1 -- R: j*x -- x1<>0 ; POSTPONE IS" POSTPONE ?ABORT ; IMMEDIATE .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ABORTQUOTE: 000929 0006 .dw $0006 00092a 6261 00092b 726f 00092c 2274 .db "abort",'"' 00092d 091e .dw VE_HEAD .set VE_HEAD = VE_ABORTQUOTE XT_ABORTQUOTE: 00092e 3800 .dw DO_COLON PFA_ABORTQUOTE: .endif 00092f 3e89 .dw XT_SQUOTE 000930 0743 .dw XT_COMPILE 000931 0940 .dw XT_QABORT 000932 381f .DW XT_EXIT .include "words/abort.asm" ; Exceptions ; send an exception -1 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ABORT: 000933 ff05 .dw $ff05 000934 6261 000935 726f 000936 0074 .db "abort",0 000937 0929 .dw VE_HEAD .set VE_HEAD = VE_ABORT XT_ABORT: 000938 3800 .dw DO_COLON PFA_ABORT: .endif 000939 394a .dw XT_TRUE 00093a 3d85 .dw XT_THROW .include "words/q-abort.asm" ; ROT IF ITYPE ABORT THEN 2DROP ; .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_QABORT: 00093b ff06 .dw $ff06 00093c 613f 00093d 6f62 00093e 7472 .db "?abort" 00093f 0933 .dw VE_HEAD .set VE_HEAD = VE_QABORT XT_QABORT: 000940 3800 .dw DO_COLON PFA_QABORT: .endif 000941 38e0 000942 3835 .DW XT_ROT,XT_DOCONDBRANCH 000943 0946 DEST(QABO1) 000944 03ea 000945 0938 .DW XT_ITYPE,XT_ABORT 000946 3ed1 000947 381f QABO1: .DW XT_2DROP,XT_EXIT .include "words/get-stack.asm" ; Tools ; Get a stack from EEPROM .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_GET_STACK: 000948 ff09 .dw $ff09 000949 6567 00094a 2d74 00094b 7473 00094c 6361 00094d 006b .db "get-stack",0 00094e 093b .dw VE_HEAD .set VE_HEAD = VE_GET_STACK XT_GET_STACK: 00094f 3800 .dw DO_COLON .endif 000950 38b0 .dw XT_DUP 000951 3c8f .dw XT_CELLPLUS 000952 38c3 .dw XT_SWAP 000953 3b5e .dw XT_FETCHE 000954 38b0 .dw XT_DUP 000955 38fe .dw XT_TO_R 000956 3953 .dw XT_ZERO 000957 38c3 .dw XT_SWAP ; go from bigger to smaller addresses 000958 080d .dw XT_QDOCHECK 000959 3835 .dw XT_DOCONDBRANCH 00095a 0966 DEST(PFA_N_FETCH_E2) 00095b 3a9a .dw XT_DODO PFA_N_FETCH_E1: ; ( ee-addr ) 00095c 3aab .dw XT_I 00095d 3a34 .dw XT_1MINUS 00095e 3ec3 .dw XT_CELLS ; ( -- ee-addr i*2 ) 00095f 38ce .dw XT_OVER ; ( -- ee-addr i*2 ee-addr ) 000960 399c .dw XT_PLUS ; ( -- ee-addr ee-addr+i 000961 3b5e .dw XT_FETCHE ;( -- ee-addr item_i ) 000962 38c3 .dw XT_SWAP ;( -- item_i ee-addr ) 000963 394a .dw XT_TRUE ; shortcut for -1 000964 3ab9 .dw XT_DOPLUSLOOP 000965 095c DEST(PFA_N_FETCH_E1) PFA_N_FETCH_E2: 000966 3ed1 .dw XT_2DROP 000967 38f5 .dw XT_R_FROM 000968 381f .dw XT_EXIT .include "words/set-stack.asm" ; Tools ; Write a stack to EEPROM .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SET_STACK: 000969 ff09 .dw $ff09 00096a 6573 00096b 2d74 00096c 7473 00096d 6361 00096e 006b .db "set-stack",0 00096f 0948 .dw VE_HEAD .set VE_HEAD = VE_SET_STACK XT_SET_STACK: 000970 3800 .dw DO_COLON PFA_SET_STACK: .endif 000971 38ce .dw XT_OVER 000972 3920 .dw XT_ZEROLESS 000973 3835 .dw XT_DOCONDBRANCH 000974 0978 DEST(PFA_SET_STACK0) 000975 383c .dw XT_DOLITERAL 000976 fffc .dw -4 000977 3d85 .dw XT_THROW PFA_SET_STACK0: 000978 3ec8 .dw XT_2DUP 000979 3b3a .dw XT_STOREE ; ( -- i_n .. i_0 n e-addr ) 00097a 38c3 .dw XT_SWAP 00097b 3953 .dw XT_ZERO 00097c 080d .dw XT_QDOCHECK 00097d 3835 .dw XT_DOCONDBRANCH 00097e 0985 DEST(PFA_SET_STACK2) 00097f 3a9a .dw XT_DODO PFA_SET_STACK1: 000980 3c8f .dw XT_CELLPLUS ; ( -- i_x e-addr ) 000981 3ed9 .dw XT_TUCK ; ( -- e-addr i_x e-addr 000982 3b3a .dw XT_STOREE 000983 3ac8 .dw XT_DOLOOP 000984 0980 DEST(PFA_SET_STACK1) PFA_SET_STACK2: 000985 38d8 .dw XT_DROP 000986 381f .dw XT_EXIT .include "words/map-stack.asm" ; Tools ; Iterate over a stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_MAPSTACK: 000987 ff09 .dw $ff09 000988 616d 000989 2d70 00098a 7473 00098b 6361 00098c 006b .db "map-stack",0 00098d 0969 .dw VE_HEAD .set VE_HEAD = VE_MAPSTACK XT_MAPSTACK: 00098e 3800 .dw DO_COLON PFA_MAPSTACK: .endif 00098f 38b0 .dw XT_DUP 000990 3c8f .dw XT_CELLPLUS 000991 38c3 .dw XT_SWAP 000992 3b5e .dw XT_FETCHE 000993 3ec3 .dw XT_CELLS 000994 3f98 .dw XT_BOUNDS 000995 080d .dw XT_QDOCHECK 000996 3835 .dw XT_DOCONDBRANCH 000997 09aa DEST(PFA_MAPSTACK3) 000998 3a9a .dw XT_DODO PFA_MAPSTACK1: 000999 3aab .dw XT_I 00099a 3b5e .dw XT_FETCHE ; -- i*x XT id 00099b 38c3 .dw XT_SWAP 00099c 38fe .dw XT_TO_R 00099d 3907 .dw XT_R_FETCH 00099e 3829 .dw XT_EXECUTE ; i*x id -- j*y true | i*x false 00099f 38b8 .dw XT_QDUP 0009a0 3835 .dw XT_DOCONDBRANCH 0009a1 09a6 DEST(PFA_MAPSTACK2) 0009a2 38f5 .dw XT_R_FROM 0009a3 38d8 .dw XT_DROP 0009a4 3ad3 .dw XT_UNLOOP 0009a5 381f .dw XT_EXIT PFA_MAPSTACK2: 0009a6 38f5 .dw XT_R_FROM 0009a7 3fea .dw XT_TWO 0009a8 3ab9 .dw XT_DOPLUSLOOP 0009a9 0999 DEST(PFA_MAPSTACK1) PFA_MAPSTACK3: 0009aa 38d8 .dw XT_DROP 0009ab 3953 .dw XT_ZERO 0009ac 381f .dw XT_EXIT ; ; : map-stack ( i*x XT e-addr -- j*y ) ; dup cell+ swap @e cells bounds ?do ; ( -- i*x XT ) ; i @e swap >r r@ execute ; ?dup if r> drop unloop exit then ; r> ; 2 +loop drop 0 ; ; .include "words/get-current.asm" ; Search Order ; get the wid of the current compilation word list VE_GET_CURRENT: 0009ad ff0b .dw $ff0b 0009ae 6567 0009af 2d74 0009b0 7563 0009b1 7272 0009b2 6e65 0009b3 0074 .db "get-current",0 0009b4 0987 .dw VE_HEAD .set VE_HEAD = VE_GET_CURRENT XT_GET_CURRENT: 0009b5 3800 .dw DO_COLON PFA_GET_CURRENT: 0009b6 383c .dw XT_DOLITERAL 0009b7 0068 .dw CFG_CURRENT 0009b8 3b5e .dw XT_FETCHE 0009b9 381f .dw XT_EXIT .include "words/get-order.asm" ; Search Order ; Get the current search order word list .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_GET_ORDER: 0009ba ff09 .dw $ff09 0009bb 6567 0009bc 2d74 0009bd 726f 0009be 6564 0009bf 0072 .db "get-order",0 0009c0 09ad .dw VE_HEAD .set VE_HEAD = VE_GET_ORDER XT_GET_ORDER: 0009c1 3800 .dw DO_COLON PFA_GET_ORDER: .endif 0009c2 383c .dw XT_DOLITERAL 0009c3 006c .dw CFG_ORDERLISTLEN 0009c4 094f .dw XT_GET_STACK 0009c5 381f .dw XT_EXIT .include "words/cfg-order.asm" ; Search Order ; Get the current search order word list .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CFG_ORDER: 0009c6 ff09 .dw $ff09 0009c7 6663 0009c8 2d67 0009c9 726f 0009ca 6564 0009cb 0072 .db "cfg-order",0 0009cc 09ba .dw VE_HEAD .set VE_HEAD = VE_CFG_ORDER XT_CFG_ORDER: 0009cd 3847 .dw PFA_DOVARIABLE PFA_CFG_ORDER: .endif 0009ce 006c .dw CFG_ORDERLISTLEN .include "words/compare.asm" ; String ; compares two strings in RAM VE_COMPARE: 0009cf ff07 .dw $ff07 0009d0 6f63 0009d1 706d 0009d2 7261 0009d3 0065 .db "compare",0 0009d4 09c6 .dw VE_HEAD .set VE_HEAD = VE_COMPARE XT_COMPARE: 0009d5 09d6 .dw PFA_COMPARE PFA_COMPARE: 0009d6 93bf push xh 0009d7 93af push xl 0009d8 018c movw temp0, tosl 0009d9 9189 0009da 9199 loadtos 0009db 01dc movw xl, tosl 0009dc 9189 0009dd 9199 loadtos 0009de 019c movw temp2, tosl 0009df 9189 0009e0 9199 loadtos 0009e1 01fc movw zl, tosl PFA_COMPARE_LOOP: 0009e2 90ed ld temp4, X+ 0009e3 90f1 ld temp5, Z+ 0009e4 14ef cp temp4, temp5 0009e5 f451 brne PFA_COMPARE_NOTEQUAL 0009e6 950a dec temp0 0009e7 f019 breq PFA_COMPARE_ENDREACHED2 0009e8 952a dec temp2 0009e9 f7c1 brne PFA_COMPARE_LOOP 0009ea c001 rjmp PFA_COMPARE_ENDREACHED PFA_COMPARE_ENDREACHED2: 0009eb 952a dec temp2 PFA_COMPARE_ENDREACHED: 0009ec 2b02 or temp0, temp2 0009ed f411 brne PFA_COMPARE_CHECKLASTCHAR 0009ee 2788 clr tosl 0009ef c002 rjmp PFA_COMPARE_DONE PFA_COMPARE_CHECKLASTCHAR: PFA_COMPARE_NOTEQUAL: 0009f0 ef8f ser tosl 0009f1 c000 rjmp PFA_COMPARE_DONE PFA_COMPARE_DONE: 0009f2 2f98 mov tosh, tosl 0009f3 91af pop xl 0009f4 91bf pop xh 0009f5 940c 3804 jmp_ DO_NEXT .include "words/nfa2lfa.asm" ; System ; get the link field address from the name field address VE_NFA2LFA: 0009f7 ff07 .dw $ff07 0009f8 666e 0009f9 3e61 0009fa 666c 0009fb 0061 .db "nfa>lfa",0 0009fc 09cf .dw VE_HEAD .set VE_HEAD = VE_NFA2LFA XT_NFA2LFA: 0009fd 3800 .dw DO_COLON PFA_NFA2LFA: 0009fe 06dc .dw XT_NAME2STRING 0009ff 3a2e .dw XT_1PLUS 000a00 3a03 .dw XT_2SLASH 000a01 399c .dw XT_PLUS 000a02 381f .dw XT_EXIT .elif AMFORTH_NRWW_SIZE > 2000 .else .endif .include "dict_appl.inc" ; they may be moved to the core dictionary if needed .include "dict/compiler2.inc" ; additional words for the compiler ; included almost independently from each other ; on a include-per-use basis ; .if DICT_COMPILER2 == 0 .set DICT_COMPILER2 = 1 .include "words/set-current.asm" ; Search Order ; set current word list to the given word list wid VE_SET_CURRENT: 000a03 ff0b .dw $ff0b 000a04 6573 000a05 2d74 000a06 7563 000a07 7272 000a08 6e65 000a09 0074 .db "set-current",0 000a0a 09f7 .dw VE_HEAD .set VE_HEAD = VE_SET_CURRENT XT_SET_CURRENT: 000a0b 3800 .dw DO_COLON PFA_SET_CURRENT: 000a0c 383c .dw XT_DOLITERAL 000a0d 0068 .dw CFG_CURRENT 000a0e 3b3a .dw XT_STOREE 000a0f 381f .dw XT_EXIT .include "words/wordlist.asm" ; Search Order ; create a new, empty wordlist VE_WORDLIST: 000a10 ff08 .dw $ff08 000a11 6f77 000a12 6472 000a13 696c 000a14 7473 .db "wordlist" 000a15 0a03 .dw VE_HEAD .set VE_HEAD = VE_WORDLIST XT_WORDLIST: 000a16 3800 .dw DO_COLON PFA_WORDLIST: 000a17 3f1a .dw XT_EHERE 000a18 3953 .dw XT_ZERO 000a19 38ce .dw XT_OVER 000a1a 3b3a .dw XT_STOREE 000a1b 38b0 .dw XT_DUP 000a1c 3c8f .dw XT_CELLPLUS 000a1d 0195 .dw XT_DOTO 000a1e 3f1b .dw PFA_EHERE 000a1f 381f .dw XT_EXIT .include "words/forth-wordlist.asm" ; Search Order ; get the system default word list VE_FORTHWORDLIST: 000a20 ff0e .dw $ff0e 000a21 6f66 000a22 7472 000a23 2d68 000a24 6f77 000a25 6472 000a26 696c 000a27 7473 .db "forth-wordlist" 000a28 0a10 .dw VE_HEAD .set VE_HEAD = VE_FORTHWORDLIST XT_FORTHWORDLIST: 000a29 3847 .dw PFA_DOVARIABLE PFA_FORTHWORDLIST: 000a2a 006a .dw CFG_FORTHWORDLIST .include "words/set-order.asm" ; Search Order ; replace the search order list .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SET_ORDER: 000a2b ff09 .dw $ff09 000a2c 6573 000a2d 2d74 000a2e 726f 000a2f 6564 000a30 0072 .db "set-order",0 000a31 0a20 .dw VE_HEAD .set VE_HEAD = VE_SET_ORDER XT_SET_ORDER: 000a32 3800 .dw DO_COLON PFA_SET_ORDER: .endif 000a33 383c .dw XT_DOLITERAL 000a34 006c .dw CFG_ORDERLISTLEN 000a35 0970 .dw XT_SET_STACK 000a36 381f .dw XT_EXIT .include "words/set-recognizer.asm" ; Interpreter ; replace the recognizer list .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SET_RECOGNIZERS: 000a37 ff0f .dw $ff0f 000a38 6573 000a39 2d74 000a3a 6572 000a3b 6f63 000a3c 6e67 000a3d 7a69 000a3e 7265 000a3f 0073 .db "set-recognizers",0 000a40 0a2b .dw VE_HEAD .set VE_HEAD = VE_SET_RECOGNIZERS XT_SET_RECOGNIZERS: 000a41 3800 .dw DO_COLON PFA_SET_RECOGNIZERS: .endif 000a42 383c .dw XT_DOLITERAL 000a43 007e .dw CFG_RECOGNIZERLISTLEN 000a44 0970 .dw XT_SET_STACK 000a45 381f .dw XT_EXIT .include "words/get-recognizer.asm" ; Interpreter ; Get the current recognizer list .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_GET_RECOGNIZERS: 000a46 ff0f .dw $ff0f 000a47 6567 000a48 2d74 000a49 6572 000a4a 6f63 000a4b 6e67 000a4c 7a69 000a4d 7265 000a4e 0073 .db "get-recognizers",0 000a4f 0a37 .dw VE_HEAD .set VE_HEAD = VE_GET_RECOGNIZERS XT_GET_RECOGNIZERS: 000a50 3800 .dw DO_COLON PFA_GET_RECOGNIZERS: .endif 000a51 383c .dw XT_DOLITERAL 000a52 007e .dw CFG_RECOGNIZERLISTLEN 000a53 094f .dw XT_GET_STACK 000a54 381f .dw XT_EXIT .include "words/code.asm" ; Compiler ; create named entry in the dictionary, XT is the data field VE_CODE: 000a55 ff04 .dw $ff04 000a56 6f63 000a57 6564 .db "code" 000a58 0a46 .dw VE_HEAD .set VE_HEAD = VE_CODE XT_CODE: 000a59 3800 .dw DO_COLON PFA_CODE: 000a5a 0720 .dw XT_DOCREATE 000a5b 0880 .dw XT_REVEAL 000a5c 3f11 .dw XT_DP 000a5d 01a7 .dw XT_ICELLPLUS 000a5e 074e .dw XT_COMMA 000a5f 381f .dw XT_EXIT .include "words/end-code.asm" ; Compiler ; finish a code definition VE_ENDCODE: 000a60 ff08 .dw $ff08 000a61 6e65 000a62 2d64 000a63 6f63 000a64 6564 .db "end-code" 000a65 0a55 .dw VE_HEAD .set VE_HEAD = VE_ENDCODE XT_ENDCODE: 000a66 3800 .dw DO_COLON PFA_ENDCODE: 000a67 0743 .dw XT_COMPILE 000a68 940c .dw $940c 000a69 0743 .dw XT_COMPILE 000a6a 3804 .dw DO_NEXT 000a6b 381f .dw XT_EXIT .include "words/marker.asm" ; System Value ; The eeprom address until which MARKER saves and restores the eeprom data. VE_MARKER: 000a6c ff08 .dw $ff08 000a6d 6d28 000a6e 7261 000a6f 656b 000a70 2972 .db "(marker)" 000a71 0a60 .dw VE_HEAD .set VE_HEAD = VE_MARKER XT_MARKER: 000a72 386e .dw PFA_DOVALUE1 PFA_MARKER: 000a73 008a .dw EE_MARKER 000a74 3d9f .dw XT_EDEFERFETCH 000a75 3da9 .dw XT_EDEFERSTORE .include "words/postpone.asm" ; Compiler ; Append the compilation semantics of "name" to the dictionary .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_POSTPONE: 000a76 0008 .dw $0008 000a77 6f70 000a78 7473 000a79 6f70 000a7a 656e .db "postpone" 000a7b 0a6c .dw VE_HEAD .set VE_HEAD = VE_POSTPONE XT_POSTPONE: 000a7c 3800 .dw DO_COLON PFA_POSTPONE: .endif 000a7d 05a2 .dw XT_PARSENAME 000a7e 05e5 .dw XT_FORTHRECOGNIZER 000a7f 05f0 .dw XT_RECOGNIZE 000a80 38b0 .dw XT_DUP 000a81 38fe .dw XT_TO_R 000a82 01a7 .dw XT_ICELLPLUS 000a83 01a7 .dw XT_ICELLPLUS 000a84 3bca .dw XT_FETCHI 000a85 3829 .dw XT_EXECUTE 000a86 38f5 .dw XT_R_FROM 000a87 01a7 .dw XT_ICELLPLUS 000a88 3bca .dw XT_FETCHI 000a89 074e .dw XT_COMMA 000a8a 381f .dw XT_EXIT .endif .include "words/applturnkey.asm" ; R( -- ) ; application specific turnkey action VE_APPLTURNKEY: 000a8b ff0b .dw $ff0b 000a8c 7061 000a8d 6c70 000a8e 7574 000a8f 6e72 000a90 656b 000a91 0079 .db "applturnkey",0 000a92 0a76 .dw VE_HEAD .set VE_HEAD = VE_APPLTURNKEY XT_APPLTURNKEY: 000a93 3800 .dw DO_COLON PFA_APPLTURNKEY: 000a94 00e9 .dw XT_USART .if WANT_INTERRUPTS == 1 000a95 3c96 .dw XT_INTON .endif 000a96 0160 .dw XT_DOT_VER 000a97 3fad .dw XT_SPACE 000a98 03b7 .dw XT_DOSLITERAL 000a99 000a .dw 10 000a9a 6f46 000a9b 7472 000a9c 6468 000a9d 6975 000a9e 6f6e .db "Forthduino" 000a9f 03ea .dw XT_ITYPE 000aa0 381f .dw XT_EXIT .set DPSTART = pc .if(pc>AMFORTH_RO_SEG) .endif .org AMFORTH_RO_SEG .include "amforth-interpreter.asm" DO_COLON: 003800 93bf push XH 003801 93af push XL ; PUSH IP 003802 01db movw XL, wl 003803 9611 adiw xl, 1 DO_NEXT: .if WANT_INTERRUPTS == 1 003804 14b2 cp isrflag, zerol 003805 f469 brne DO_INTERRUPT .endif 003806 01fd movw zl, XL ; READ IP 003807 0fee 003808 1fff 003809 9165 00380a 9175 readflashcell wl, wh 00380b 9611 adiw XL, 1 ; INC IP DO_EXECUTE: 00380c 01fb movw zl, wl 00380d 0fee 00380e 1fff 00380f 9105 003810 9115 readflashcell temp0,temp1 003811 01f8 movw zl, temp0 003812 9409 ijmp .if WANT_INTERRUPTS == 1 DO_INTERRUPT: ; here we deal with interrupts the forth way 003813 939a 003814 938a savetos 003815 2d8b mov tosl, isrflag 003816 2799 clr tosh 003817 24bb clr isrflag 003818 eb6f ldi wl, LOW(XT_ISREXEC) 003819 e37c ldi wh, HIGH(XT_ISREXEC) 00381a cff1 rjmp DO_EXECUTE .include "dict/nrww.inc" ; section together with the forth inner interpreter .include "words/exit.asm" ; Compiler ; end of current colon word VE_EXIT: 00381b ff04 .dw $ff04 00381c 7865 00381d 7469 .db "exit" 00381e 0a8b .dw VE_HEAD .set VE_HEAD = VE_EXIT XT_EXIT: 00381f 3820 .dw PFA_EXIT PFA_EXIT: 003820 91af pop XL 003821 91bf pop XH 003822 cfe1 jmp_ DO_NEXT .include "words/execute.asm" ; System ; execute XT VE_EXECUTE: 003823 ff07 .dw $ff07 003824 7865 003825 6365 003826 7475 003827 0065 .db "execute",0 003828 381b .dw VE_HEAD .set VE_HEAD = VE_EXECUTE XT_EXECUTE: 003829 382a .dw PFA_EXECUTE PFA_EXECUTE: 00382a 01bc movw wl, tosl 00382b 9189 00382c 9199 loadtos 00382d cfde jmp_ DO_EXECUTE .include "words/dobranch.asm" ; System ; runtime of branch ;VE_DOBRANCH: ; .dw $ff08 ; .db "(branch)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOBRANCH XT_DOBRANCH: 00382e 382f .dw PFA_DOBRANCH PFA_DOBRANCH: 00382f 01fd movw zl, XL 003830 0fee 003831 1fff 003832 91a5 003833 91b5 readflashcell XL,XH 003834 cfcf jmp_ DO_NEXT .include "words/docondbranch.asm" ; System ; runtime of ?branch ;VE_DOCONDBRANCH: ; .dw $ff09 ; .db "(?branch)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOCONDBRANCH XT_DOCONDBRANCH: 003835 3836 .dw PFA_DOCONDBRANCH PFA_DOCONDBRANCH: 003836 2b98 or tosh, tosl 003837 9189 003838 9199 loadtos 003839 f3a9 brbs 1, PFA_DOBRANCH ; 1 is z flag; if tos is zero (false), do the branch 00383a 9611 adiw XL, 1 00383b cfc8 jmp_ DO_NEXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/doliteral.asm" ; System ; runtime of literal ;VE_DOLITERAL: ; .dw $ff09 ; .db "(literal)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOLITERAL XT_DOLITERAL: 00383c 383d .dw PFA_DOLITERAL PFA_DOLITERAL: 00383d 939a 00383e 938a savetos 00383f 01fd movw zl, xl 003840 0fee 003841 1fff 003842 9185 003843 9195 readflashcell tosl,tosh 003844 9611 adiw xl, 1 003845 cfbe jmp_ DO_NEXT .include "words/dovariable.asm" ; System ; puts content of parameter field (1 cell) to TOS ;VE_DOVARIABLE: ; .dw $ff0a ; .db "(variable)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOVARIABLE XT_DOVARIABLE: 003846 3847 .dw PFA_DOVARIABLE PFA_DOVARIABLE: 003847 939a 003848 938a savetos 003849 01fb movw zl, wl 00384a 9631 adiw zl,1 00384b 0fee 00384c 1fff 00384d 9185 00384e 9195 readflashcell tosl,tosh 00384f cfb4 jmp_ DO_NEXT .include "words/doconstant.asm" ; System ; place data field address on TOS ;VE_DOCONSTANT: ; .dw $ff0a ; .db "(constant)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOCONSTANT XT_DOCONSTANT: 003850 3851 .dw PFA_DOCONSTANT PFA_DOCONSTANT: 003851 939a 003852 938a savetos 003853 01cb movw tosl, wl 003854 9601 adiw tosl, 1 003855 cfae jmp_ DO_NEXT .include "words/douser.asm" ; System ; runtime part of user ;VE_DOUSER: ; .dw $ff06 ; .db "(user)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOUSER XT_DOUSER: 003856 3857 .dw PFA_DOUSER PFA_DOUSER: 003857 939a 003858 938a savetos 003859 01fb movw zl, wl 00385a 9631 adiw zl, 1 00385b 0fee 00385c 1fff 00385d 9185 00385e 9195 readflashcell tosl,tosh 00385f 0d84 add tosl, upl 003860 1d95 adc tosh, uph 003861 cfa2 jmp_ DO_NEXT .include "words/do-value.asm" ; System ; runtime of value VE_DOVALUE: 003862 ff07 .dw $ff07 003863 7628 003864 6c61 003865 6575 003866 0029 .db "(value)", 0 003867 3823 .dw VE_HEAD .set VE_HEAD = VE_DOVALUE XT_DOVALUE: 003868 3800 .dw DO_COLON PFA_DOVALUE: 003869 0720 .dw XT_DOCREATE 00386a 0880 .dw XT_REVEAL 00386b 0743 .dw XT_COMPILE 00386c 386e .dw PFA_DOVALUE1 00386d 381f .dw XT_EXIT PFA_DOVALUE1: 00386e 940e 0899 call_ DO_DODOES 003870 38b0 .dw XT_DUP 003871 01a7 .dw XT_ICELLPLUS 003872 3bca .dw XT_FETCHI 003873 3829 .dw XT_EXECUTE 003874 381f .dw XT_EXIT ; : (value) dup icell+ @i execute ; .include "words/fetch.asm" ; Memory ; read 1 cell from RAM address VE_FETCH: 003875 ff01 .dw $ff01 003876 0040 .db "@",0 003877 3862 .dw VE_HEAD .set VE_HEAD = VE_FETCH XT_FETCH: 003878 3879 .dw PFA_FETCH PFA_FETCH: .if WANT_UNIFIED == 1 .endif PFA_FETCHRAM: 003879 01fc movw zl, tosl ; low byte is read before the high byte 00387a 9181 ld tosl, z+ 00387b 9191 ld tosh, z+ 00387c cf87 jmp_ DO_NEXT .if WANT_UNIFIED == 1 .endif .include "words/store.asm" ; Memory ; write n to RAM memory at addr, low byte first VE_STORE: 00387d ff01 .dw $ff01 00387e 0021 .db "!",0 00387f 3875 .dw VE_HEAD .set VE_HEAD = VE_STORE XT_STORE: 003880 3881 .dw PFA_STORE PFA_STORE: .if WANT_UNIFIED == 1 .endif PFA_STORERAM: 003881 01fc movw zl, tosl 003882 9189 003883 9199 loadtos ; the high byte is written before the low byte 003884 8391 std Z+1, tosh 003885 8380 std Z+0, tosl 003886 9189 003887 9199 loadtos 003888 cf7b jmp_ DO_NEXT .if WANT_UNIFIED == 1 .endif .include "words/cstore.asm" ; Memory ; store a single byte to RAM address VE_CSTORE: 003889 ff02 .dw $ff02 00388a 2163 .db "c!" 00388b 387d .dw VE_HEAD .set VE_HEAD = VE_CSTORE XT_CSTORE: 00388c 388d .dw PFA_CSTORE PFA_CSTORE: 00388d 01fc movw zl, tosl 00388e 9189 00388f 9199 loadtos 003890 8380 st Z, tosl 003891 9189 003892 9199 loadtos 003893 cf70 jmp_ DO_NEXT .include "words/cfetch.asm" ; Memory ; fetch a single byte from memory mapped locations VE_CFETCH: 003894 ff02 .dw $ff02 003895 4063 .db "c@" 003896 3889 .dw VE_HEAD .set VE_HEAD = VE_CFETCH XT_CFETCH: 003897 3898 .dw PFA_CFETCH PFA_CFETCH: 003898 01fc movw zl, tosl 003899 2799 clr tosh 00389a 8180 ld tosl, Z 00389b cf68 jmp_ DO_NEXT .include "words/fetch-u.asm" ; Memory ; read 1 cell from USER area VE_FETCHU: 00389c ff02 .dw $ff02 00389d 7540 .db "@u" 00389e 3894 .dw VE_HEAD .set VE_HEAD = VE_FETCHU XT_FETCHU: 00389f 3800 .dw DO_COLON PFA_FETCHU: 0038a0 3b01 .dw XT_UP_FETCH 0038a1 399c .dw XT_PLUS 0038a2 3878 .dw XT_FETCH 0038a3 381f .dw XT_EXIT .include "words/store-u.asm" ; Memory ; write n to USER area at offset VE_STOREU: 0038a4 ff02 .dw $ff02 0038a5 7521 .db "!u" 0038a6 389c .dw VE_HEAD .set VE_HEAD = VE_STOREU XT_STOREU: 0038a7 3800 .dw DO_COLON PFA_STOREU: 0038a8 3b01 .dw XT_UP_FETCH 0038a9 399c .dw XT_PLUS 0038aa 3880 .dw XT_STORE 0038ab 381f .dw XT_EXIT ;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/dup.asm" ; Stack ; duplicate TOS VE_DUP: 0038ac ff03 .dw $ff03 0038ad 7564 0038ae 0070 .db "dup",0 0038af 38a4 .dw VE_HEAD .set VE_HEAD = VE_DUP XT_DUP: 0038b0 38b1 .dw PFA_DUP PFA_DUP: 0038b1 939a 0038b2 938a savetos 0038b3 cf50 jmp_ DO_NEXT .include "words/qdup.asm" ; Stack ; duplicate TOS if non-zero VE_QDUP: 0038b4 ff04 .dw $ff04 0038b5 643f 0038b6 7075 .db "?dup" 0038b7 38ac .dw VE_HEAD .set VE_HEAD = VE_QDUP XT_QDUP: 0038b8 38b9 .dw PFA_QDUP PFA_QDUP: 0038b9 2f08 mov temp0, tosl 0038ba 2b09 or temp0, tosh 0038bb f011 breq PFA_QDUP1 0038bc 939a 0038bd 938a savetos PFA_QDUP1: 0038be cf45 jmp_ DO_NEXT .include "words/swap.asm" ; Stack ; swaps the two top level stack cells VE_SWAP: 0038bf ff04 .dw $ff04 0038c0 7773 0038c1 7061 .db "swap" 0038c2 38b4 .dw VE_HEAD .set VE_HEAD = VE_SWAP XT_SWAP: 0038c3 38c4 .dw PFA_SWAP PFA_SWAP: 0038c4 018c movw temp0, tosl 0038c5 9189 0038c6 9199 loadtos 0038c7 931a st -Y, temp1 0038c8 930a st -Y, temp0 0038c9 cf3a jmp_ DO_NEXT .include "words/over.asm" ; Stack ; Place a copy of x1 on top of the stack VE_OVER: 0038ca ff04 .dw $ff04 0038cb 766f 0038cc 7265 .db "over" 0038cd 38bf .dw VE_HEAD .set VE_HEAD = VE_OVER XT_OVER: 0038ce 38cf .dw PFA_OVER PFA_OVER: 0038cf 939a 0038d0 938a savetos 0038d1 818a ldd tosl, Y+2 0038d2 819b ldd tosh, Y+3 0038d3 cf30 jmp_ DO_NEXT .include "words/drop.asm" ; Stack ; drop TOS VE_DROP: 0038d4 ff04 .dw $ff04 0038d5 7264 0038d6 706f .db "drop" 0038d7 38ca .dw VE_HEAD .set VE_HEAD = VE_DROP XT_DROP: 0038d8 38d9 .dw PFA_DROP PFA_DROP: 0038d9 9189 0038da 9199 loadtos 0038db cf28 jmp_ DO_NEXT .include "words/rot.asm" ; Stack ; rotate the three top level cells VE_ROT: 0038dc ff03 .dw $ff03 0038dd 6f72 0038de 0074 .db "rot",0 0038df 38d4 .dw VE_HEAD .set VE_HEAD = VE_ROT XT_ROT: 0038e0 38e1 .dw PFA_ROT PFA_ROT: 0038e1 018c movw temp0, tosl 0038e2 9129 ld temp2, Y+ 0038e3 9139 ld temp3, Y+ 0038e4 9189 0038e5 9199 loadtos 0038e6 933a st -Y, temp3 0038e7 932a st -Y, temp2 0038e8 931a st -Y, temp1 0038e9 930a st -Y, temp0 0038ea cf19 jmp_ DO_NEXT .include "words/nip.asm" ; Stack ; Remove Second of Stack VE_NIP: 0038eb ff03 .dw $ff03 0038ec 696e 0038ed 0070 .db "nip",0 0038ee 38dc .dw VE_HEAD .set VE_HEAD = VE_NIP XT_NIP: 0038ef 38f0 .dw PFA_NIP PFA_NIP: 0038f0 9622 adiw yl, 2 0038f1 cf12 jmp_ DO_NEXT ;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/r_from.asm" ; Stack ; move TOR to TOS VE_R_FROM: 0038f2 ff02 .dw $ff02 0038f3 3e72 .db "r>" 0038f4 38eb .dw VE_HEAD .set VE_HEAD = VE_R_FROM XT_R_FROM: 0038f5 38f6 .dw PFA_R_FROM PFA_R_FROM: 0038f6 939a 0038f7 938a savetos 0038f8 918f pop tosl 0038f9 919f pop tosh 0038fa cf09 jmp_ DO_NEXT .include "words/to_r.asm" ; Stack ; move TOS to TOR VE_TO_R: 0038fb ff02 .dw $ff02 0038fc 723e .db ">r" 0038fd 38f2 .dw VE_HEAD .set VE_HEAD = VE_TO_R XT_TO_R: 0038fe 38ff .dw PFA_TO_R PFA_TO_R: 0038ff 939f push tosh 003900 938f push tosl 003901 9189 003902 9199 loadtos 003903 cf00 jmp_ DO_NEXT .include "words/r_fetch.asm" ; Stack ; fetch content of TOR VE_R_FETCH: 003904 ff02 .dw $ff02 003905 4072 .db "r@" 003906 38fb .dw VE_HEAD .set VE_HEAD = VE_R_FETCH XT_R_FETCH: 003907 3908 .dw PFA_R_FETCH PFA_R_FETCH: 003908 939a 003909 938a savetos 00390a 918f pop tosl 00390b 919f pop tosh 00390c 939f push tosh 00390d 938f push tosl 00390e cef5 jmp_ DO_NEXT .include "words/not-equal.asm" ; Compare ; true if n1 is not equal to n2 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_NOTEQUAL: 00390f ff02 .dw $ff02 003910 3e3c .db "<>" 003911 3904 .dw VE_HEAD .set VE_HEAD = VE_NOTEQUAL XT_NOTEQUAL: 003912 3800 .dw DO_COLON PFA_NOTEQUAL: .endif 003913 3fde 003914 3919 003915 381f .DW XT_EQUAL,XT_ZEROEQUAL,XT_EXIT .include "words/equalzero.asm" ; Compare ; compare with 0 (zero) VE_ZEROEQUAL: 003916 ff02 .dw $ff02 003917 3d30 .db "0=" 003918 390f .dw VE_HEAD .set VE_HEAD = VE_ZEROEQUAL XT_ZEROEQUAL: 003919 391a .dw PFA_ZEROEQUAL PFA_ZEROEQUAL: 00391a 2b98 or tosh, tosl 00391b f5d1 brne PFA_ZERO1 00391c c030 rjmp PFA_TRUE1 .include "words/lesszero.asm" ; Compare ; compare with zero VE_ZEROLESS: 00391d ff02 .dw $ff02 00391e 3c30 .db "0<" 00391f 3916 .dw VE_HEAD .set VE_HEAD = VE_ZEROLESS XT_ZEROLESS: 003920 3921 .dw PFA_ZEROLESS PFA_ZEROLESS: 003921 fd97 sbrc tosh,7 003922 c02a rjmp PFA_TRUE1 003923 c032 rjmp PFA_ZERO1 .include "words/greaterzero.asm" ; Compare ; true if n1 is greater than 0 VE_GREATERZERO: 003924 ff02 .dw $ff02 003925 3e30 .db "0>" 003926 391d .dw VE_HEAD .set VE_HEAD = VE_GREATERZERO XT_GREATERZERO: 003927 3928 .dw PFA_GREATERZERO PFA_GREATERZERO: 003928 1582 cp tosl, zerol 003929 0593 cpc tosh, zeroh 00392a f15c brlt PFA_ZERO1 00392b f151 brbs 1, PFA_ZERO1 00392c c020 rjmp PFA_TRUE1 .include "words/d-greaterzero.asm" ; Compare ; compares if a double double cell number is greater 0 VE_DGREATERZERO: 00392d ff03 .dw $ff03 00392e 3064 00392f 003e .db "d0>",0 003930 3924 .dw VE_HEAD .set VE_HEAD = VE_DGREATERZERO XT_DGREATERZERO: 003931 3932 .dw PFA_DGREATERZERO PFA_DGREATERZERO: 003932 1582 cp tosl, zerol 003933 0593 cpc tosh, zeroh 003934 9189 003935 9199 loadtos 003936 0582 cpc tosl, zerol 003937 0593 cpc tosh, zeroh 003938 f0ec brlt PFA_ZERO1 003939 f0e1 brbs 1, PFA_ZERO1 00393a c012 rjmp PFA_TRUE1 .include "words/d-lesszero.asm" ; Compare ; compares if a double double cell number is less than 0 VE_DXT_ZEROLESS: 00393b ff03 .dw $ff03 00393c 3064 00393d 003c .db "d0<",0 00393e 392d .dw VE_HEAD .set VE_HEAD = VE_DXT_ZEROLESS XT_DXT_ZEROLESS: 00393f 3940 .dw PFA_DXT_ZEROLESS PFA_DXT_ZEROLESS: 003940 9622 adiw Y,2 003941 fd97 sbrc tosh,7 003942 940c 394d jmp PFA_TRUE1 003944 940c 3956 jmp PFA_ZERO1 .include "words/true.asm" ; Arithmetics ; leaves the value -1 (true) on TOS VE_TRUE: 003946 ff04 .dw $ff04 003947 7274 003948 6575 .db "true" 003949 393b .dw VE_HEAD .set VE_HEAD = VE_TRUE XT_TRUE: 00394a 394b .dw PFA_TRUE PFA_TRUE: 00394b 939a 00394c 938a savetos PFA_TRUE1: 00394d ef8f ser tosl 00394e ef9f ser tosh 00394f ceb4 jmp_ DO_NEXT .include "words/zero.asm" ; Arithmetics ; place a value 0 on TOS VE_ZERO: 003950 ff01 .dw $ff01 003951 0030 .db "0",0 003952 3946 .dw VE_HEAD .set VE_HEAD = VE_ZERO XT_ZERO: 003953 3954 .dw PFA_ZERO PFA_ZERO: 003954 939a 003955 938a savetos PFA_ZERO1: 003956 01c1 movw tosl, zerol 003957 ceac jmp_ DO_NEXT .include "words/uless.asm" ; Compare ; true if u1 < u2 (unsigned) VE_ULESS: 003958 ff02 .dw $ff02 003959 3c75 .db "u<" 00395a 3950 .dw VE_HEAD .set VE_HEAD = VE_ULESS XT_ULESS: 00395b 395c .dw PFA_ULESS PFA_ULESS: 00395c 9129 ld temp2, Y+ 00395d 9139 ld temp3, Y+ 00395e 1782 cp tosl, temp2 00395f 0793 cpc tosh, temp3 003960 f3a8 brlo PFA_ZERO1 003961 f3a1 brbs 1, PFA_ZERO1 003962 cfea jmp_ PFA_TRUE1 .include "words/u-greater.asm" ; Compare ; true if u1 > u2 (unsigned) .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UGREATER: 003963 ff02 .dw $ff02 003964 3e75 .db "u>" 003965 3958 .dw VE_HEAD .set VE_HEAD = VE_UGREATER XT_UGREATER: 003966 3800 .dw DO_COLON PFA_UGREATER: .endif 003967 38c3 .DW XT_SWAP 003968 395b .dw XT_ULESS 003969 381f .dw XT_EXIT .include "words/less.asm" ; Compare ; true if n1 is less than n2 VE_LESS: 00396a ff01 .dw $ff01 00396b 003c .db "<",0 00396c 3963 .dw VE_HEAD .set VE_HEAD = VE_LESS XT_LESS: 00396d 396e .dw PFA_LESS PFA_LESS: 00396e 9129 ld temp2, Y+ 00396f 9139 ld temp3, Y+ 003970 1728 cp temp2, tosl 003971 0739 cpc temp3, tosh PFA_LESSDONE: 003972 f71c brge PFA_ZERO1 003973 cfd9 rjmp PFA_TRUE1 .include "words/greater.asm" ; Compare ; flag is true if n1 is greater than n2 VE_GREATER: 003974 ff01 .dw $ff01 003975 003e .db ">",0 003976 396a .dw VE_HEAD .set VE_HEAD = VE_GREATER XT_GREATER: 003977 3978 .dw PFA_GREATER PFA_GREATER: 003978 9129 ld temp2, Y+ 003979 9139 ld temp3, Y+ 00397a 1728 cp temp2, tosl 00397b 0739 cpc temp3, tosh PFA_GREATERDONE: 00397c f2cc brlt PFA_ZERO1 00397d f2c1 brbs 1, PFA_ZERO1 00397e cfce rjmp PFA_TRUE1 .include "words/log2.asm" ; Arithmetics ; logarithm to base 2 or highest set bitnumber VE_LOG2: 00397f ff04 .dw $ff04 003980 6f6c 003981 3267 .db "log2" 003982 3974 .dw VE_HEAD .set VE_HEAD = VE_LOG2 XT_LOG2: 003983 3984 .dw PFA_LOG2 PFA_LOG2: 003984 01fc movw zl, tosl 003985 2799 clr tosh 003986 e180 ldi tosl, 16 PFA_LOG2_1: 003987 958a dec tosl 003988 f022 brmi PFA_LOG2_2 ; wrong data 003989 0fee lsl zl 00398a 1fff rol zh 00398b f7d8 brcc PFA_LOG2_1 00398c ce77 jmp_ DO_NEXT PFA_LOG2_2: 00398d 959a dec tosh 00398e ce75 jmp_ DO_NEXT .include "words/minus.asm" ; Arithmetics ; subtract n2 from n1 VE_MINUS: 00398f ff01 .dw $ff01 003990 002d .db "-",0 003991 397f .dw VE_HEAD .set VE_HEAD = VE_MINUS XT_MINUS: 003992 3993 .dw PFA_MINUS PFA_MINUS: 003993 9109 ld temp0, Y+ 003994 9119 ld temp1, Y+ 003995 1b08 sub temp0, tosl 003996 0b19 sbc temp1, tosh 003997 01c8 movw tosl, temp0 003998 ce6b jmp_ DO_NEXT .include "words/plus.asm" ; Arithmetics ; add n1 and n2 VE_PLUS: 003999 ff01 .dw $ff01 00399a 002b .db "+",0 00399b 398f .dw VE_HEAD .set VE_HEAD = VE_PLUS XT_PLUS: 00399c 399d .dw PFA_PLUS PFA_PLUS: 00399d 9109 ld temp0, Y+ 00399e 9119 ld temp1, Y+ 00399f 0f80 add tosl, temp0 0039a0 1f91 adc tosh, temp1 0039a1 ce62 jmp_ DO_NEXT .include "words/mstar.asm" ; Arithmetics ; multiply 2 cells to a double cell VE_MSTAR: 0039a2 ff02 .dw $ff02 0039a3 2a6d .db "m*" 0039a4 3999 .dw VE_HEAD .set VE_HEAD = VE_MSTAR XT_MSTAR: 0039a5 39a6 .dw PFA_MSTAR PFA_MSTAR: 0039a6 018c movw temp0, tosl 0039a7 9189 0039a8 9199 loadtos 0039a9 019c movw temp2, tosl ; high cell ah*bh 0039aa 0231 muls temp3, temp1 0039ab 0170 movw temp4, r0 ; low cell al*bl 0039ac 9f20 mul temp2, temp0 0039ad 01c0 movw tosl, r0 ; signed ah*bl 0039ae 0330 mulsu temp3, temp0 0039af 08f3 sbc temp5, zeroh 0039b0 0d90 add tosh, r0 0039b1 1ce1 adc temp4, r1 0039b2 1cf3 adc temp5, zeroh ; signed al*bh 0039b3 0312 mulsu temp1, temp2 0039b4 08f3 sbc temp5, zeroh 0039b5 0d90 add tosh, r0 0039b6 1ce1 adc temp4, r1 0039b7 1cf3 adc temp5, zeroh 0039b8 939a 0039b9 938a savetos 0039ba 01c7 movw tosl, temp4 0039bb ce48 jmp_ DO_NEXT .include "words/umslashmod.asm" ; Arithmetics ; unsigned division ud / u2 with remainder VE_UMSLASHMOD: 0039bc ff06 .dw $ff06 0039bd 6d75 0039be 6d2f 0039bf 646f .db "um/mod" 0039c0 39a2 .dw VE_HEAD .set VE_HEAD = VE_UMSLASHMOD XT_UMSLASHMOD: 0039c1 39c2 .dw PFA_UMSLASHMOD PFA_UMSLASHMOD: 0039c2 017c movw temp4, tosl 0039c3 9129 ld temp2, Y+ 0039c4 9139 ld temp3, Y+ 0039c5 9109 ld temp0, Y+ 0039c6 9119 ld temp1, Y+ ;; unsigned 32/16 -> 16r16 divide PFA_UMSLASHMODmod: ; set loop counter 0039c7 e140 ldi temp6,$10 PFA_UMSLASHMODmod_loop: ; shift left, saving high bit 0039c8 2755 clr temp7 0039c9 0f00 lsl temp0 0039ca 1f11 rol temp1 0039cb 1f22 rol temp2 0039cc 1f33 rol temp3 0039cd 1f55 rol temp7 ; try subtracting divisor 0039ce 152e cp temp2, temp4 0039cf 053f cpc temp3, temp5 0039d0 0552 cpc temp7,zerol 0039d1 f018 brcs PFA_UMSLASHMODmod_loop_control PFA_UMSLASHMODmod_subtract: ; dividend is large enough ; do the subtraction for real ; and set lowest bit 0039d2 9503 inc temp0 0039d3 192e sub temp2, temp4 0039d4 093f sbc temp3, temp5 PFA_UMSLASHMODmod_loop_control: 0039d5 954a dec temp6 0039d6 f789 brne PFA_UMSLASHMODmod_loop PFA_UMSLASHMODmod_done: ; put remainder on stack 0039d7 933a st -Y,temp3 0039d8 932a st -Y,temp2 ; put quotient on stack 0039d9 01c8 movw tosl, temp0 0039da ce29 jmp_ DO_NEXT .include "words/umstar.asm" ; Arithmetics ; multiply 2 unsigned cells to a double cell VE_UMSTAR: 0039db ff03 .dw $ff03 0039dc 6d75 0039dd 002a .db "um*",0 0039de 39bc .dw VE_HEAD .set VE_HEAD = VE_UMSTAR XT_UMSTAR: 0039df 39e0 .dw PFA_UMSTAR PFA_UMSTAR: 0039e0 018c movw temp0, tosl 0039e1 9189 0039e2 9199 loadtos ; result: (temp3*temp1)* 65536 + (temp3*temp0 + temp1*temp2) * 256 + (temp0 * temp2) ; low bytes 0039e3 9f80 mul tosl,temp0 0039e4 01f0 movw zl, r0 0039e5 2722 clr temp2 0039e6 2733 clr temp3 ; middle bytes 0039e7 9f90 mul tosh, temp0 0039e8 0df0 add zh, r0 0039e9 1d21 adc temp2, r1 0039ea 1d33 adc temp3, zeroh 0039eb 9f81 mul tosl, temp1 0039ec 0df0 add zh, r0 0039ed 1d21 adc temp2, r1 0039ee 1d33 adc temp3, zeroh 0039ef 9f91 mul tosh, temp1 0039f0 0d20 add temp2, r0 0039f1 1d31 adc temp3, r1 0039f2 01cf movw tosl, zl 0039f3 939a 0039f4 938a savetos 0039f5 01c9 movw tosl, temp2 0039f6 ce0d jmp_ DO_NEXT .include "words/invert.asm" ; Arithmetics ; 1-complement of TOS VE_INVERT: 0039f7 ff06 .dw $ff06 0039f8 6e69 0039f9 6576 0039fa 7472 .db "invert" 0039fb 39db .dw VE_HEAD .set VE_HEAD = VE_INVERT XT_INVERT: 0039fc 39fd .dw PFA_INVERT PFA_INVERT: 0039fd 9580 com tosl 0039fe 9590 com tosh 0039ff ce04 jmp_ DO_NEXT .include "words/2slash.asm" ; Arithmetics ; arithmetic shift right VE_2SLASH: 003a00 ff02 .dw $ff02 003a01 2f32 .db "2/" 003a02 39f7 .dw VE_HEAD .set VE_HEAD = VE_2SLASH XT_2SLASH: 003a03 3a04 .dw PFA_2SLASH PFA_2SLASH: 003a04 9595 asr tosh 003a05 9587 ror tosl 003a06 cdfd jmp_ DO_NEXT .include "words/2star.asm" ; Arithmetics ; arithmetic shift left, filling with zero VE_2STAR: 003a07 ff02 .dw $ff02 003a08 2a32 .db "2*" 003a09 3a00 .dw VE_HEAD .set VE_HEAD = VE_2STAR XT_2STAR: 003a0a 3a0b .dw PFA_2STAR PFA_2STAR: 003a0b 0f88 lsl tosl 003a0c 1f99 rol tosh 003a0d cdf6 jmp_ DO_NEXT .include "words/and.asm" ; Logic ; bitwise and VE_AND: 003a0e ff03 .dw $ff03 003a0f 6e61 003a10 0064 .db "and",0 003a11 3a07 .dw VE_HEAD .set VE_HEAD = VE_AND XT_AND: 003a12 3a13 .dw PFA_AND PFA_AND: 003a13 9109 ld temp0, Y+ 003a14 9119 ld temp1, Y+ 003a15 2380 and tosl, temp0 003a16 2391 and tosh, temp1 003a17 cdec jmp_ DO_NEXT .include "words/or.asm" ; Logic ; logical or VE_OR: 003a18 ff02 .dw $ff02 003a19 726f .db "or" 003a1a 3a0e .dw VE_HEAD .set VE_HEAD = VE_OR XT_OR: 003a1b 3a1c .dw PFA_OR PFA_OR: 003a1c 9109 ld temp0, Y+ 003a1d 9119 ld temp1, Y+ 003a1e 2b80 or tosl, temp0 003a1f 2b91 or tosh, temp1 003a20 cde3 jmp_ DO_NEXT .include "words/xor.asm" ; Logic ; exclusive or VE_XOR: 003a21 ff03 .dw $ff03 003a22 6f78 003a23 0072 .db "xor",0 003a24 3a18 .dw VE_HEAD .set VE_HEAD = VE_XOR XT_XOR: 003a25 3a26 .dw PFA_XOR PFA_XOR: 003a26 9109 ld temp0, Y+ 003a27 9119 ld temp1, Y+ 003a28 2780 eor tosl, temp0 003a29 2791 eor tosh, temp1 003a2a cdd9 jmp_ DO_NEXT .include "words/1plus.asm" ; Arithmetics ; optimized increment VE_1PLUS: 003a2b ff02 .dw $ff02 003a2c 2b31 .db "1+" 003a2d 3a21 .dw VE_HEAD .set VE_HEAD = VE_1PLUS XT_1PLUS: 003a2e 3a2f .dw PFA_1PLUS PFA_1PLUS: 003a2f 9601 adiw tosl,1 003a30 cdd3 jmp_ DO_NEXT .include "words/1minus.asm" ; Arithmetics ; optimized decrement VE_1MINUS: 003a31 ff02 .dw $ff02 003a32 2d31 .db "1-" 003a33 3a2b .dw VE_HEAD .set VE_HEAD = VE_1MINUS XT_1MINUS: 003a34 3a35 .dw PFA_1MINUS PFA_1MINUS: 003a35 9701 sbiw tosl, 1 003a36 cdcd jmp_ DO_NEXT .include "words/q-negate.asm" ; 0< IF NEGATE THEN ; ...a common factor .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_QNEGATE: 003a37 ff07 .dw $ff07 003a38 6e3f 003a39 6765 003a3a 7461 ../../common\words/q-negate.asm(11): warning: .cseg .db misalignment - padding zero byte 003a3b 0065 .db "?negate" 003a3c 3a31 .dw VE_HEAD .set VE_HEAD = VE_QNEGATE XT_QNEGATE: 003a3d 3800 .dw DO_COLON PFA_QNEGATE: .endif 003a3e 3920 003a3f 3835 .DW XT_ZEROLESS,XT_DOCONDBRANCH 003a40 3a42 DEST(QNEG1) 003a41 3e26 .DW XT_NEGATE 003a42 381f QNEG1: .DW XT_EXIT .include "words/lshift.asm" ; Arithmetics ; logically shift n1 left n2 times VE_LSHIFT: 003a43 ff06 .dw $ff06 003a44 736c 003a45 6968 003a46 7466 .db "lshift" 003a47 3a37 .dw VE_HEAD .set VE_HEAD = VE_LSHIFT XT_LSHIFT: 003a48 3a49 .dw PFA_LSHIFT PFA_LSHIFT: 003a49 01fc movw zl, tosl 003a4a 9189 003a4b 9199 loadtos PFA_LSHIFT1: 003a4c 9731 sbiw zl, 1 003a4d f01a brmi PFA_LSHIFT2 003a4e 0f88 lsl tosl 003a4f 1f99 rol tosh 003a50 cffb rjmp PFA_LSHIFT1 PFA_LSHIFT2: 003a51 cdb2 jmp_ DO_NEXT .include "words/rshift.asm" ; Arithmetics ; shift n1 n2-times logically right VE_RSHIFT: 003a52 ff06 .dw $ff06 003a53 7372 003a54 6968 003a55 7466 .db "rshift" 003a56 3a43 .dw VE_HEAD .set VE_HEAD = VE_RSHIFT XT_RSHIFT: 003a57 3a58 .dw PFA_RSHIFT PFA_RSHIFT: 003a58 01fc movw zl, tosl 003a59 9189 003a5a 9199 loadtos PFA_RSHIFT1: 003a5b 9731 sbiw zl, 1 003a5c f01a brmi PFA_RSHIFT2 003a5d 9596 lsr tosh 003a5e 9587 ror tosl 003a5f cffb rjmp PFA_RSHIFT1 PFA_RSHIFT2: 003a60 cda3 jmp_ DO_NEXT .include "words/plusstore.asm" ; Arithmetics ; add n to content of RAM address a-addr VE_PLUSSTORE: 003a61 ff02 .dw $ff02 003a62 212b .db "+!" 003a63 3a52 .dw VE_HEAD .set VE_HEAD = VE_PLUSSTORE XT_PLUSSTORE: 003a64 3a65 .dw PFA_PLUSSTORE PFA_PLUSSTORE: 003a65 01fc movw zl, tosl 003a66 9189 003a67 9199 loadtos 003a68 8120 ldd temp2, Z+0 003a69 8131 ldd temp3, Z+1 003a6a 0f82 add tosl, temp2 003a6b 1f93 adc tosh, temp3 003a6c 8380 std Z+0, tosl 003a6d 8391 std Z+1, tosh 003a6e 9189 003a6f 9199 loadtos 003a70 cd93 jmp_ DO_NEXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/rpfetch.asm" ; Stack ; current return stack pointer address VE_RP_FETCH: 003a71 ff03 .dw $ff03 003a72 7072 003a73 0040 .db "rp@",0 003a74 3a61 .dw VE_HEAD .set VE_HEAD = VE_RP_FETCH XT_RP_FETCH: 003a75 3a76 .dw PFA_RP_FETCH PFA_RP_FETCH: 003a76 939a 003a77 938a savetos 003a78 b78d in tosl, SPL 003a79 b79e in tosh, SPH 003a7a cd89 jmp_ DO_NEXT .include "words/rpstore.asm" ; Stack ; set return stack pointer VE_RP_STORE: 003a7b ff03 .dw $ff03 003a7c 7072 003a7d 0021 .db "rp!",0 003a7e 3a71 .dw VE_HEAD .set VE_HEAD = VE_RP_STORE XT_RP_STORE: 003a7f 3a80 .dw PFA_RP_STORE PFA_RP_STORE: 003a80 b72f in temp2, SREG 003a81 94f8 cli 003a82 bf8d out SPL, tosl 003a83 bf9e out SPH, tosh 003a84 bf2f out SREG, temp2 003a85 9189 003a86 9199 loadtos 003a87 cd7c jmp_ DO_NEXT .include "words/spfetch.asm" ; Stack ; current data stack pointer VE_SP_FETCH: 003a88 ff03 .dw $ff03 003a89 7073 003a8a 0040 .db "sp@",0 003a8b 3a7b .dw VE_HEAD .set VE_HEAD = VE_SP_FETCH XT_SP_FETCH: 003a8c 3a8d .dw PFA_SP_FETCH PFA_SP_FETCH: 003a8d 939a 003a8e 938a savetos 003a8f 01ce movw tosl, yl 003a90 cd73 jmp_ DO_NEXT .include "words/spstore.asm" ; Stack ; set data stack pointer to addr VE_SP_STORE: 003a91 ff03 .dw $ff03 003a92 7073 003a93 0021 .db "sp!",0 003a94 3a88 .dw VE_HEAD .set VE_HEAD = VE_SP_STORE XT_SP_STORE: 003a95 3a96 .dw PFA_SP_STORE PFA_SP_STORE: 003a96 01ec movw yl, tosl 003a97 9189 003a98 9199 loadtos 003a99 cd6a jmp_ DO_NEXT .include "words/dodo.asm" ; System ; runtime of do ;VE_DODO: ; .dw $ff04 ; .db "(do)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DODO XT_DODO: 003a9a 3a9b .dw PFA_DODO PFA_DODO: 003a9b 9129 ld temp2, Y+ 003a9c 9139 ld temp3, Y+ ; limit PFA_DODO1: 003a9d e8e0 ldi zl, $80 003a9e 0f3e add temp3, zl 003a9f 1b82 sub tosl, temp2 003aa0 0b93 sbc tosh, temp3 003aa1 933f push temp3 003aa2 932f push temp2 ; limit ( --> limit + $8000) 003aa3 939f push tosh 003aa4 938f push tosl ; start -> index ( --> index - (limit - $8000) 003aa5 9189 003aa6 9199 loadtos 003aa7 cd5c jmp_ DO_NEXT .include "words/i.asm" ; Compiler ; current loop counter VE_I: 003aa8 ff01 .dw $FF01 003aa9 0069 .db "i",0 003aaa 3a91 .dw VE_HEAD .set VE_HEAD = VE_I XT_I: 003aab 3aac .dw PFA_I PFA_I: 003aac 939a 003aad 938a savetos 003aae 918f pop tosl 003aaf 919f pop tosh ; index 003ab0 91ef pop zl 003ab1 91ff pop zh ; limit 003ab2 93ff push zh 003ab3 93ef push zl 003ab4 939f push tosh 003ab5 938f push tosl 003ab6 0f8e add tosl, zl 003ab7 1f9f adc tosh, zh 003ab8 cd4b jmp_ DO_NEXT .include "words/doplusloop.asm" ; System ; runtime of +loop ;VE_DOPLUSLOOP: ; .dw $ff07 ; .db "(+loop)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOPLUSLOOP XT_DOPLUSLOOP: 003ab9 3aba .dw PFA_DOPLUSLOOP PFA_DOPLUSLOOP: 003aba 91ef pop zl 003abb 91ff pop zh 003abc 0fe8 add zl, tosl 003abd 1ff9 adc zh, tosh 003abe 9189 003abf 9199 loadtos 003ac0 f01b brvs PFA_DOPLUSLOOP_LEAVE ; next cycle PFA_DOPLUSLOOP_NEXT: ; next iteration 003ac1 93ff push zh 003ac2 93ef push zl 003ac3 cd6b rjmp PFA_DOBRANCH ; read next cell from dictionary and jump to its destination PFA_DOPLUSLOOP_LEAVE: 003ac4 910f pop temp0 003ac5 911f pop temp1 ; remove limit 003ac6 9611 adiw xl, 1 ; skip branch-back address 003ac7 cd3c jmp_ DO_NEXT .include "words/doloop.asm" ; System ; runtime of loop ;VE_DOLOOP: ; .dw $ff06 ; .db "(loop)" ; .dw VE_HEAD ; .set VE_HEAD = VE_DOLOOP XT_DOLOOP: 003ac8 3ac9 .dw PFA_DOLOOP PFA_DOLOOP: 003ac9 91ef pop zl 003aca 91ff pop zh 003acb 9631 adiw zl,1 003acc f3bb brvs PFA_DOPLUSLOOP_LEAVE 003acd cff3 jmp_ PFA_DOPLUSLOOP_NEXT .include "words/unloop.asm" ; Compiler ; remove loop-sys, exit the loop and continue execution after it VE_UNLOOP: 003ace ff06 .dw $ff06 003acf 6e75 003ad0 6f6c 003ad1 706f .db "unloop" 003ad2 3aa8 .dw VE_HEAD .set VE_HEAD = VE_UNLOOP XT_UNLOOP: 003ad3 3ad4 .dw PFA_UNLOOP PFA_UNLOOP: 003ad4 911f pop temp1 003ad5 910f pop temp0 003ad6 911f pop temp1 003ad7 910f pop temp0 003ad8 cd2b jmp_ DO_NEXT ;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/cmove_g.asm" ; Memory ; copy data in RAM from higher to lower addresses. VE_CMOVE_G: 003ad9 ff06 .dw $ff06 003ada 6d63 003adb 766f 003adc 3e65 .db "cmove>" 003add 3ace .dw VE_HEAD .set VE_HEAD = VE_CMOVE_G XT_CMOVE_G: 003ade 3adf .dw PFA_CMOVE_G PFA_CMOVE_G: 003adf 93bf push xh 003ae0 93af push xl 003ae1 91e9 ld zl, Y+ 003ae2 91f9 ld zh, Y+ ; addr-to 003ae3 91a9 ld xl, Y+ 003ae4 91b9 ld xh, Y+ ; addr-from 003ae5 2f09 mov temp0, tosh 003ae6 2b08 or temp0, tosl 003ae7 f041 brbs 1, PFA_CMOVE_G1 003ae8 0fe8 add zl, tosl 003ae9 1ff9 adc zh, tosh 003aea 0fa8 add xl, tosl 003aeb 1fb9 adc xh, tosh PFA_CMOVE_G2: 003aec 911e ld temp1, -X 003aed 9312 st -Z, temp1 003aee 9701 sbiw tosl, 1 003aef f7e1 brbc 1, PFA_CMOVE_G2 PFA_CMOVE_G1: 003af0 91af pop xl 003af1 91bf pop xh 003af2 9189 003af3 9199 loadtos 003af4 cd0f jmp_ DO_NEXT .include "words/byteswap.asm" ; Arithmetics ; exchange the bytes of the TOS VE_BYTESWAP: 003af5 ff02 .dw $ff02 003af6 3c3e .db "><" 003af7 3ad9 .dw VE_HEAD .set VE_HEAD = VE_BYTESWAP XT_BYTESWAP: 003af8 3af9 .dw PFA_BYTESWAP PFA_BYTESWAP: 003af9 2f09 mov temp0, tosh 003afa 2f98 mov tosh, tosl 003afb 2f80 mov tosl, temp0 003afc cd07 jmp_ DO_NEXT .include "words/up.asm" ; System Variable ; get user area pointer VE_UP_FETCH: 003afd ff03 .dw $ff03 003afe 7075 003aff 0040 .db "up@",0 003b00 3af5 .dw VE_HEAD .set VE_HEAD = VE_UP_FETCH XT_UP_FETCH: 003b01 3b02 .dw PFA_UP_FETCH PFA_UP_FETCH: 003b02 939a 003b03 938a savetos 003b04 01c2 movw tosl, upl 003b05 ccfe jmp_ DO_NEXT ; ( addr -- ) ; System Variable ; set user area pointer VE_UP_STORE: 003b06 ff03 .dw $ff03 003b07 7075 003b08 0021 .db "up!",0 003b09 3afd .dw VE_HEAD .set VE_HEAD = VE_UP_STORE XT_UP_STORE: 003b0a 3b0b .dw PFA_UP_STORE PFA_UP_STORE: 003b0b 012c movw upl, tosl 003b0c 9189 003b0d 9199 loadtos 003b0e ccf5 jmp_ DO_NEXT .include "words/1ms.asm" ; Time ; busy waits (almost) exactly 1 millisecond VE_1MS: 003b0f ff03 .dw $ff03 003b10 6d31 003b11 0073 .db "1ms",0 003b12 3b06 .dw VE_HEAD .set VE_HEAD = VE_1MS XT_1MS: 003b13 3b14 .dw PFA_1MS PFA_1MS: 003b14 eae0 003b15 e0ff 003b16 9731 003b17 f7f1 delay 1000 003b18 cceb jmp_ DO_NEXT .include "words/2to_r.asm" ; Stack ; move DTOS to TOR VE_2TO_R: 003b19 ff03 .dw $ff03 003b1a 3e32 003b1b 0072 .db "2>r",0 003b1c 3b0f .dw VE_HEAD .set VE_HEAD = VE_2TO_R XT_2TO_R: 003b1d 3b1e .dw PFA_2TO_R PFA_2TO_R: 003b1e 01fc movw zl, tosl 003b1f 9189 003b20 9199 loadtos 003b21 939f push tosh 003b22 938f push tosl 003b23 93ff push zh 003b24 93ef push zl 003b25 9189 003b26 9199 loadtos 003b27 ccdc jmp_ DO_NEXT .include "words/2r_from.asm" ; Stack ; move DTOR to TOS VE_2R_FROM: 003b28 ff03 .dw $ff03 003b29 7232 003b2a 003e .db "2r>",0 003b2b 3b19 .dw VE_HEAD .set VE_HEAD = VE_2R_FROM XT_2R_FROM: 003b2c 3b2d .dw PFA_2R_FROM PFA_2R_FROM: 003b2d 939a 003b2e 938a savetos 003b2f 91ef pop zl 003b30 91ff pop zh 003b31 918f pop tosl 003b32 919f pop tosh 003b33 939a 003b34 938a savetos 003b35 01cf movw tosl, zl 003b36 cccd jmp_ DO_NEXT .include "words/store-e.asm" ; Memory ; write n (2bytes) to eeprom address VE_STOREE: 003b37 ff02 .dw $ff02 003b38 6521 .db "!e" 003b39 3b28 .dw VE_HEAD .set VE_HEAD = VE_STOREE XT_STOREE: 003b3a 3b3b .dw PFA_STOREE PFA_STOREE: .if WANT_UNIFIED == 1 .endif PFA_STOREE0: 003b3b 01fc movw zl, tosl 003b3c 9189 003b3d 9199 loadtos 003b3e b72f in_ temp2, SREG 003b3f 94f8 cli 003b40 d028 rcall PFA_FETCHE2 003b41 b500 in_ temp0, EEDR 003b42 1708 cp temp0,tosl 003b43 f009 breq PFA_STOREE3 003b44 d00b rcall PFA_STOREE1 PFA_STOREE3: 003b45 9631 adiw zl,1 003b46 d022 rcall PFA_FETCHE2 003b47 b500 in_ temp0, EEDR 003b48 1709 cp temp0,tosh 003b49 f011 breq PFA_STOREE4 003b4a 2f89 mov tosl, tosh 003b4b d004 rcall PFA_STOREE1 PFA_STOREE4: 003b4c bf2f out_ SREG, temp2 003b4d 9189 003b4e 9199 loadtos 003b4f ccb4 jmp_ DO_NEXT PFA_STOREE1: 003b50 99f9 sbic EECR, EEPE 003b51 cffe rjmp PFA_STOREE1 PFA_STOREE2: ; estore_wait_low_spm: 003b52 b707 in_ temp0, SPMCSR 003b53 fd00 sbrc temp0,SPMEN 003b54 cffd rjmp PFA_STOREE2 003b55 bdf2 out_ EEARH,zh 003b56 bde1 out_ EEARL,zl 003b57 bd80 out_ EEDR, tosl 003b58 9afa sbi EECR,EEMPE 003b59 9af9 sbi EECR,EEPE 003b5a 9508 ret .if WANT_UNIFIED == 1 .endif .include "words/fetch-e.asm" ; Memory ; read 1 cell from eeprom VE_FETCHE: 003b5b ff02 .dw $ff02 003b5c 6540 .db "@e" 003b5d 3b37 .dw VE_HEAD .set VE_HEAD = VE_FETCHE XT_FETCHE: 003b5e 3b5f .dw PFA_FETCHE PFA_FETCHE: .if WANT_UNIFIED == 1 .endif PFA_FETCHE1: 003b5f b72f in_ temp2, SREG 003b60 94f8 cli 003b61 01fc movw zl, tosl 003b62 d006 rcall PFA_FETCHE2 003b63 b580 in_ tosl, EEDR 003b64 9631 adiw zl,1 003b65 d003 rcall PFA_FETCHE2 003b66 b590 in_ tosh, EEDR 003b67 bf2f out_ SREG, temp2 003b68 cc9b jmp_ DO_NEXT PFA_FETCHE2: 003b69 99f9 sbic EECR, EEPE 003b6a cffe rjmp PFA_FETCHE2 003b6b bdf2 out_ EEARH,zh 003b6c bde1 out_ EEARL,zl 003b6d 9af8 sbi EECR,EERE 003b6e 9508 ret .if WANT_UNIFIED == 1 .endif .include "words/store-i.asm" ; System Value ; Deferred action to write a single 16bit cell to flash VE_STOREI: 003b6f ff02 .dw $ff02 003b70 6921 .db "!i" 003b71 3b5b .dw VE_HEAD .set VE_HEAD = VE_STOREI XT_STOREI: 003b72 3dfe .dw PFA_DODEFER1 PFA_STOREI: 003b73 0088 .dw EE_STOREI 003b74 3d9f .dw XT_EDEFERFETCH 003b75 3da9 .dw XT_EDEFERSTORE .if FLASHEND > $10000 .else .include "words/store-i_nrww.asm" ; Memory ; writes n to flash memory using assembly code (code to be placed in boot loader section) VE_DO_STOREI_NRWW: 003b76 ff09 .dw $ff09 003b77 2128 003b78 2d69 003b79 726e 003b7a 7777 003b7b 0029 .db "(!i-nrww)",0 003b7c 3b6f .dw VE_HEAD .set VE_HEAD = VE_DO_STOREI_NRWW XT_DO_STOREI: 003b7d 3b7e .dw PFA_DO_STOREI_NRWW PFA_DO_STOREI_NRWW: ; store status register 003b7e b71f in temp1,SREG 003b7f 931f push temp1 003b80 94f8 cli 003b81 019c movw temp2, tosl ; save the (word) address 003b82 9189 003b83 9199 loadtos ; get the new value for the flash cell 003b84 93af push xl 003b85 93bf push xh 003b86 93cf push yl 003b87 93df push yh 003b88 d009 rcall DO_STOREI_atmega 003b89 91df pop yh 003b8a 91cf pop yl 003b8b 91bf pop xh 003b8c 91af pop xl ; finally clear the stack 003b8d 9189 003b8e 9199 loadtos 003b8f 911f pop temp1 ; restore status register (and interrupt enable flag) 003b90 bf1f out SREG,temp1 003b91 cc72 jmp_ DO_NEXT ; DO_STOREI_atmega: ; write data to temp page buffer ; use the values in tosl/tosh at the ; appropiate place 003b92 d010 rcall pageload ; erase page if needed ; it is needed if a bit goes from 0 to 1 003b93 94e0 com temp4 003b94 94f0 com temp5 003b95 218e and tosl, temp4 003b96 219f and tosh, temp5 003b97 2b98 or tosh, tosl 003b98 f019 breq DO_STOREI_writepage 003b99 01f9 movw zl, temp2 003b9a e002 ldi temp0,(1<8000 .elif AMFORTH_NRWW_SIZE>4000 .include "dict/core_4k.inc" ; in a short distance to DO_NEXT .include "words/n_to_r.asm" ; Stack ; move n items from data stack to return stack VE_N_TO_R: 003bd1 ff03 .dw $ff03 003bd2 3e6e 003bd3 0072 .db "n>r",0 003bd4 3bc7 .dw VE_HEAD .set VE_HEAD = VE_N_TO_R XT_N_TO_R: 003bd5 3bd6 .dw PFA_N_TO_R PFA_N_TO_R: 003bd6 01fc movw zl, tosl 003bd7 2f08 mov temp0, tosl PFA_N_TO_R1: 003bd8 9189 003bd9 9199 loadtos 003bda 939f push tosh 003bdb 938f push tosl 003bdc 950a dec temp0 003bdd f7d1 brne PFA_N_TO_R1 003bde 93ef push zl 003bdf 93ff push zh 003be0 9189 003be1 9199 loadtos 003be2 cc21 jmp_ DO_NEXT .include "words/n_r_from.asm" ; Stack ; move n items from return stack to data stack VE_N_R_FROM: 003be3 ff03 .dw $ff03 003be4 726e 003be5 003e .db "nr>",0 003be6 3bd1 .dw VE_HEAD .set VE_HEAD = VE_N_R_FROM XT_N_R_FROM: 003be7 3be8 .dw PFA_N_R_FROM PFA_N_R_FROM: 003be8 939a 003be9 938a savetos 003bea 91ff pop zh 003beb 91ef pop zl 003bec 2f0e mov temp0, zl PFA_N_R_FROM1: 003bed 918f pop tosl 003bee 919f pop tosh 003bef 939a 003bf0 938a savetos 003bf1 950a dec temp0 003bf2 f7d1 brne PFA_N_R_FROM1 003bf3 01cf movw tosl, zl 003bf4 cc0f jmp_ DO_NEXT .include "words/d-2star.asm" ; Arithmetics ; shift a double cell left VE_D2STAR: 003bf5 ff03 .dw $ff03 003bf6 3264 003bf7 002a .db "d2*",0 003bf8 3be3 .dw VE_HEAD .set VE_HEAD = VE_D2STAR XT_D2STAR: 003bf9 3bfa .dw PFA_D2STAR PFA_D2STAR: 003bfa 9109 ld temp0, Y+ 003bfb 9119 ld temp1, Y+ 003bfc 0f00 lsl temp0 003bfd 1f11 rol temp1 003bfe 1f88 rol tosl 003bff 1f99 rol tosh 003c00 931a st -Y, temp1 003c01 930a st -Y, temp0 003c02 cc01 jmp_ DO_NEXT .include "words/d-2slash.asm" ; Arithmetics ; shift a double cell value right VE_D2SLASH: 003c03 ff03 .dw $ff03 003c04 3264 003c05 002f .db "d2/",0 003c06 3bf5 .dw VE_HEAD .set VE_HEAD = VE_D2SLASH XT_D2SLASH: 003c07 3c08 .dw PFA_D2SLASH PFA_D2SLASH: 003c08 9109 ld temp0, Y+ 003c09 9119 ld temp1, Y+ 003c0a 9595 asr tosh 003c0b 9587 ror tosl 003c0c 9517 ror temp1 003c0d 9507 ror temp0 003c0e 931a st -Y, temp1 003c0f 930a st -Y, temp0 003c10 cbf3 jmp_ DO_NEXT .include "words/d-plus.asm" ; Arithmetics ; add 2 double cell values VE_DPLUS: 003c11 ff02 .dw $ff02 003c12 2b64 .db "d+" 003c13 3c03 .dw VE_HEAD .set VE_HEAD = VE_DPLUS XT_DPLUS: 003c14 3c15 .dw PFA_DPLUS PFA_DPLUS: 003c15 9129 ld temp2, Y+ 003c16 9139 ld temp3, Y+ 003c17 90e9 ld temp4, Y+ 003c18 90f9 ld temp5, Y+ 003c19 9149 ld temp6, Y+ 003c1a 9159 ld temp7, Y+ 003c1b 0f24 add temp2, temp6 003c1c 1f35 adc temp3, temp7 003c1d 1d8e adc tosl, temp4 003c1e 1d9f adc tosh, temp5 003c1f 933a st -Y, temp3 003c20 932a st -Y, temp2 003c21 cbe2 jmp_ DO_NEXT .include "words/d-minus.asm" ; Arithmetics ; subtract d2 from d1 VE_DMINUS: 003c22 ff02 .dw $ff02 003c23 2d64 .db "d-" 003c24 3c11 .dw VE_HEAD .set VE_HEAD = VE_DMINUS XT_DMINUS: 003c25 3c26 .dw PFA_DMINUS PFA_DMINUS: 003c26 9129 ld temp2, Y+ 003c27 9139 ld temp3, Y+ 003c28 90e9 ld temp4, Y+ 003c29 90f9 ld temp5, Y+ 003c2a 9149 ld temp6, Y+ 003c2b 9159 ld temp7, Y+ 003c2c 1b42 sub temp6, temp2 003c2d 0b53 sbc temp7, temp3 003c2e 0ae8 sbc temp4, tosl 003c2f 0af9 sbc temp5, tosh 003c30 935a st -Y, temp7 003c31 934a st -Y, temp6 003c32 01c7 movw tosl, temp4 003c33 cbd0 jmp_ DO_NEXT .include "words/d-invert.asm" ; Arithmetics ; invert all bits in the double cell value VE_DINVERT: 003c34 ff07 .dw $ff07 003c35 6964 003c36 766e 003c37 7265 003c38 0074 .db "dinvert",0 003c39 3c22 .dw VE_HEAD .set VE_HEAD = VE_DINVERT XT_DINVERT: 003c3a 3c3b .dw PFA_DINVERT PFA_DINVERT: 003c3b 9109 ld temp0, Y+ 003c3c 9119 ld temp1, Y+ 003c3d 9580 com tosl 003c3e 9590 com tosh 003c3f 9500 com temp0 003c40 9510 com temp1 003c41 931a st -Y, temp1 003c42 930a st -Y, temp0 003c43 cbc0 jmp_ DO_NEXT .include "words/slashmod.asm" ; Arithmetics ; signed division n1/n2 with remainder and quotient VE_SLASHMOD: 003c44 ff04 .dw $ff04 003c45 6d2f 003c46 646f .db "/mod" 003c47 3c34 .dw VE_HEAD .set VE_HEAD = VE_SLASHMOD XT_SLASHMOD: 003c48 3c49 .dw PFA_SLASHMOD PFA_SLASHMOD: 003c49 019c movw temp2, tosl 003c4a 9109 ld temp0, Y+ 003c4b 9119 ld temp1, Y+ 003c4c 2f41 mov temp6,temp1 ;move dividend High to sign register 003c4d 2743 eor temp6,temp3 ;xor divisor High with sign register 003c4e ff17 sbrs temp1,7 ;if MSB in dividend set 003c4f c004 rjmp PFA_SLASHMOD_1 003c50 9510 com temp1 ; change sign of dividend 003c51 9500 com temp0 003c52 5f0f subi temp0,low(-1) 003c53 4f1f sbci temp1,high(-1) PFA_SLASHMOD_1: 003c54 ff37 sbrs temp3,7 ;if MSB in divisor set 003c55 c004 rjmp PFA_SLASHMOD_2 003c56 9530 com temp3 ; change sign of divisor 003c57 9520 com temp2 003c58 5f2f subi temp2,low(-1) 003c59 4f3f sbci temp3,high(-1) 003c5a 24ee PFA_SLASHMOD_2: clr temp4 ;clear remainder Low byte 003c5b 18ff sub temp5,temp5;clear remainder High byte and carry 003c5c e151 ldi temp7,17 ;init loop counter 003c5d 1f00 PFA_SLASHMOD_3: rol temp0 ;shift left dividend 003c5e 1f11 rol temp1 003c5f 955a dec temp7 ;decrement counter 003c60 f439 brne PFA_SLASHMOD_5 ;if done 003c61 ff47 sbrs temp6,7 ; if MSB in sign register set 003c62 c004 rjmp PFA_SLASHMOD_4 003c63 9510 com temp1 ; change sign of result 003c64 9500 com temp0 003c65 5f0f subi temp0,low(-1) 003c66 4f1f sbci temp1,high(-1) 003c67 c00b PFA_SLASHMOD_4: rjmp PFA_SLASHMODmod_done ; return 003c68 1cee PFA_SLASHMOD_5: rol temp4 ;shift dividend into remainder 003c69 1cff rol temp5 003c6a 1ae2 sub temp4,temp2 ;remainder = remainder - divisor 003c6b 0af3 sbc temp5,temp3 ; 003c6c f420 brcc PFA_SLASHMOD_6 ;if result negative 003c6d 0ee2 add temp4,temp2 ; restore remainder 003c6e 1ef3 adc temp5,temp3 003c6f 9488 clc ; clear carry to be shifted into result 003c70 cfec rjmp PFA_SLASHMOD_3 ;else 003c71 9408 PFA_SLASHMOD_6: sec ; set carry to be shifted into result 003c72 cfea rjmp PFA_SLASHMOD_3 PFA_SLASHMODmod_done: ; put remainder on stack 003c73 92fa st -Y,temp5 003c74 92ea st -Y,temp4 ; put quotient on stack 003c75 01c8 movw tosl, temp0 003c76 cb8d jmp_ DO_NEXT .include "words/abs.asm" ; DUP ?NEGATE ; .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ABS: 003c77 ff03 .dw $ff03 003c78 6261 003c79 0073 .db "abs",0 003c7a 3c44 .dw VE_HEAD .set VE_HEAD = VE_ABS XT_ABS: 003c7b 3800 .dw DO_COLON PFA_ABS: .endif 003c7c 38b0 003c7d 3a3d 003c7e 381f .DW XT_DUP,XT_QNEGATE,XT_EXIT .include "words/pick.asm" .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PICK: 003c7f ff04 .dw $ff04 003c80 6970 003c81 6b63 .db "pick" 003c82 3c77 .dw VE_HEAD .set VE_HEAD = VE_PICK XT_PICK: 003c83 3800 .dw DO_COLON PFA_PICK: .endif 003c84 3a2e .dw XT_1PLUS 003c85 3ec3 .dw XT_CELLS 003c86 3a8c .dw XT_SP_FETCH 003c87 399c .dw XT_PLUS 003c88 3878 .dw XT_FETCH 003c89 381f .dw XT_EXIT .include "words/cellplus.asm" ; Arithmetics ; add the size of an address-unit to a-addr1 VE_CELLPLUS: 003c8a ff05 .dw $ff05 003c8b 6563 003c8c 6c6c 003c8d 002b .db "cell+",0 003c8e 3c7f .dw VE_HEAD .set VE_HEAD = VE_CELLPLUS XT_CELLPLUS: 003c8f 3c90 .dw PFA_CELLPLUS PFA_CELLPLUS: 003c90 9602 adiw tosl, CELLSIZE 003c91 cb72 jmp_ DO_NEXT .include "dict/interrupt.inc" .if WANT_INTERRUPTS == 1 .if WANT_INTERRUPT_COUNTERS == 1 .endif .include "words/int-on.asm" ; Interrupt ; turns on all interrupts VE_INTON: 003c92 ff04 .dw $ff04 003c93 692b 003c94 746e .db "+int" 003c95 3c8a .dw VE_HEAD .set VE_HEAD = VE_INTON XT_INTON: 003c96 3c97 .dw PFA_INTON PFA_INTON: 003c97 9478 sei 003c98 cb6b jmp_ DO_NEXT .include "words/int-off.asm" ; Interrupt ; turns off all interrupts VE_INTOFF: 003c99 ff04 .dw $ff04 003c9a 692d 003c9b 746e .db "-int" 003c9c 3c92 .dw VE_HEAD .set VE_HEAD = VE_INTOFF XT_INTOFF: 003c9d 3c9e .dw PFA_INTOFF PFA_INTOFF: 003c9e 94f8 cli 003c9f cb64 jmp_ DO_NEXT .include "words/int-store.asm" ; Interrupt ; stores XT as interrupt vector i VE_INTSTORE: 003ca0 ff04 .dw $ff04 003ca1 6e69 003ca2 2174 .db "int!" 003ca3 3c99 .dw VE_HEAD .set VE_HEAD = VE_INTSTORE XT_INTSTORE: 003ca4 3800 .dw DO_COLON PFA_INTSTORE: 003ca5 383c .dw XT_DOLITERAL 003ca6 0000 .dw intvec 003ca7 399c .dw XT_PLUS 003ca8 3b3a .dw XT_STOREE 003ca9 381f .dw XT_EXIT .include "words/int-fetch.asm" ; Interrupt ; fetches XT from interrupt vector i VE_INTFETCH: 003caa ff04 .dw $ff04 003cab 6e69 003cac 4074 .db "int@" 003cad 3ca0 .dw VE_HEAD .set VE_HEAD = VE_INTFETCH XT_INTFETCH: 003cae 3800 .dw DO_COLON PFA_INTFETCH: 003caf 383c .dw XT_DOLITERAL 003cb0 0000 .dw intvec 003cb1 399c .dw XT_PLUS 003cb2 3b5e .dw XT_FETCHE 003cb3 381f .dw XT_EXIT .include "words/int-trap.asm" ; Interrupt ; trigger an interrupt VE_INTTRAP: 003cb4 ff08 .dw $ff08 003cb5 6e69 003cb6 2d74 003cb7 7274 003cb8 7061 .db "int-trap" 003cb9 3caa .dw VE_HEAD .set VE_HEAD = VE_INTTRAP XT_INTTRAP: 003cba 3cbb .dw PFA_INTTRAP PFA_INTTRAP: 003cbb 2eb8 mov isrflag, tosl 003cbc 9189 003cbd 9199 loadtos 003cbe cb45 jmp_ DO_NEXT .include "words/isr-exec.asm" ; Interrupt ; executes an interrupt service routine ;VE_ISREXEC: ; .dw $ff08 ; .db "isr-exec" ; .dw VE_HEAD ; .set VE_HEAD = VE_ISREXEC XT_ISREXEC: 003cbf 3800 .dw DO_COLON PFA_ISREXEC: 003cc0 3cae .dw XT_INTFETCH 003cc1 3829 .dw XT_EXECUTE 003cc2 3cc4 .dw XT_ISREND 003cc3 381f .dw XT_EXIT .include "words/isr-end.asm" ; Interrupt ; re-enables interrupts in an ISR ;VE_ISREND: ; .dw $ff07 ; .db "isr-end",0 ; .dw VE_HEAD ; .set VE_HEAD = VE_ISREND XT_ISREND: 003cc4 3cc5 .dw PFA_ISREND PFA_ISREND: 003cc5 d001 rcall PFA_ISREND1 ; clear the interrupt flag for the controller 003cc6 cb3d jmp_ DO_NEXT PFA_ISREND1: 003cc7 9518 reti .endif ; now the relocatable colon words .include "words/prompt-ok.asm" ; System ; send the READY prompt to the command line .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_PROMPTOK: ; .dw $ff02 ; .db "ok" ; .dw VE_HEAD ; .set VE_HEAD = VE_PROMPTOK XT_DEFAULT_PROMPTOK: 003cc8 3800 .dw DO_COLON PFA_DEFAULT_PROMPTOK: 003cc9 03b7 .dw XT_DOSLITERAL 003cca 0003 .dw 3 003ccb 6f20 003ccc 006b .db " ok",0 .endif 003ccd 03ea .dw XT_ITYPE 003cce 381f .dw XT_EXIT ; ------------------------ .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PROMPTOK: 003ccf ff03 .dw $FF03 003cd0 6f2e ../../common\words/prompt-ok.asm(43): warning: .cseg .db misalignment - padding zero byte 003cd1 006b .db ".ok" 003cd2 3cb4 .dw VE_HEAD .set VE_HEAD = VE_PROMPTOK XT_PROMPTOK: 003cd3 3dfe .dw PFA_DODEFER1 PFA_PROMPTOK: .endif 003cd4 001c .dw USER_P_OK 003cd5 3dc7 .dw XT_UDEFERFETCH 003cd6 3dd3 .dw XT_UDEFERSTORE .include "words/prompt-ready.asm" ; System ; process the error prompt .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_PROMPTRDY: ; .dw $ff04 ; .db "p_er" ; .dw VE_HEAD ; .set VE_HEAD = VE_PROMPTRDY XT_DEFAULT_PROMPTREADY: 003cd7 3800 .dw DO_COLON PFA_DEFAULT_PROMPTREADY: 003cd8 03b7 .dw XT_DOSLITERAL 003cd9 0002 .dw 2 003cda 203e .db "> " .endif 003cdb 3fa0 .dw XT_CR 003cdc 03ea .dw XT_ITYPE 003cdd 381f .dw XT_EXIT ; ------------------------ .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PROMPTREADY: 003cde ff06 .dw $FF06 003cdf 722e 003ce0 6165 003ce1 7964 .db ".ready" 003ce2 3ccf .dw VE_HEAD .set VE_HEAD = VE_PROMPTREADY XT_PROMPTREADY: 003ce3 3dfe .dw PFA_DODEFER1 PFA_PROMPTREADY: .endif 003ce4 0020 .dw USER_P_RDY 003ce5 3dc7 .dw XT_UDEFERFETCH 003ce6 3dd3 .dw XT_UDEFERSTORE .include "words/prompt-error.asm" ; System ; process the error prompt .if cpu_msp430==1 .endif .if cpu_avr8==1 ;VE_PROMPTERROR: ; .dw $ff04 ; .db "p_er" ; .dw VE_HEAD ; .set VE_HEAD = VE_PROMPTERROR XT_DEFAULT_PROMPTERROR: 003ce7 3800 .dw DO_COLON PFA_DEFAULT_PROMPTERROR: 003ce8 03b7 .dw XT_DOSLITERAL 003ce9 0004 .dw 4 003cea 3f20 003ceb 203f .db " ?? " .endif 003cec 03ea .dw XT_ITYPE 003ced 3ebc .dw XT_BASE 003cee 3878 .dw XT_FETCH 003cef 38fe .dw XT_TO_R 003cf0 3f40 .dw XT_DECIMAL 003cf1 036c .dw XT_DOT 003cf2 3ee1 .dw XT_TO_IN 003cf3 3878 .dw XT_FETCH 003cf4 036c .dw XT_DOT 003cf5 38f5 .dw XT_R_FROM 003cf6 3ebc .dw XT_BASE 003cf7 3880 .dw XT_STORE 003cf8 381f .dw XT_EXIT ; ------------------------ .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PROMPTERROR: 003cf9 ff06 .dw $FF06 003cfa 652e 003cfb 7272 003cfc 726f .db ".error" 003cfd 3cde .dw VE_HEAD .set VE_HEAD = VE_PROMPTERROR XT_PROMPTERROR: 003cfe 3dfe .dw PFA_DODEFER1 PFA_PROMPTERROR: .endif 003cff 001e .dw USER_P_ERR 003d00 3dc7 .dw XT_UDEFERFETCH 003d01 3dd3 .dw XT_UDEFERSTORE .include "words/quit.asm" ; System ; main loop of amforth. accept - interpret in an endless loop .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_QUIT: 003d02 ff04 .dw $ff04 003d03 7571 003d04 7469 .db "quit" 003d05 3cf9 .dw VE_HEAD .set VE_HEAD = VE_QUIT XT_QUIT: 003d06 3800 .dw DO_COLON .endif PFA_QUIT: 003d07 0843 003d08 084a 003d09 3880 .dw XT_LP0,XT_LP,XT_STORE 003d0a 05bc .dw XT_SP0 003d0b 3a95 .dw XT_SP_STORE 003d0c 05c9 .dw XT_RP0 003d0d 3a7f .dw XT_RP_STORE 003d0e 08d8 .dw XT_LBRACKET PFA_QUIT2: 003d0f 3eb6 .dw XT_STATE 003d10 3878 .dw XT_FETCH 003d11 3919 .dw XT_ZEROEQUAL 003d12 3835 .dw XT_DOCONDBRANCH 003d13 3d15 DEST(PFA_QUIT4) 003d14 3ce3 .dw XT_PROMPTREADY PFA_QUIT4: 003d15 04d0 .dw XT_REFILL 003d16 3835 .dw XT_DOCONDBRANCH 003d17 3d27 DEST(PFA_QUIT3) 003d18 383c .dw XT_DOLITERAL 003d19 0617 .dw XT_INTERPRET 003d1a 3d6f .dw XT_CATCH 003d1b 38b8 .dw XT_QDUP 003d1c 3835 .dw XT_DOCONDBRANCH 003d1d 3d27 DEST(PFA_QUIT3) 003d1e 38b0 .dw XT_DUP 003d1f 383c .dw XT_DOLITERAL 003d20 fffe .dw -2 003d21 396d .dw XT_LESS 003d22 3835 .dw XT_DOCONDBRANCH 003d23 3d25 DEST(PFA_QUIT5) 003d24 3cfe .dw XT_PROMPTERROR PFA_QUIT5: 003d25 382e .dw XT_DOBRANCH 003d26 3d07 DEST(PFA_QUIT) PFA_QUIT3: 003d27 3cd3 .dw XT_PROMPTOK 003d28 382e .dw XT_DOBRANCH 003d29 3d0f DEST(PFA_QUIT2) ; .dw XT_EXIT ; never reached .include "words/pause.asm" ; Multitasking ; Fetch pause vector and execute it. may make a context/task switch VE_PAUSE: 003d2a ff05 .dw $ff05 003d2b 6170 003d2c 7375 003d2d 0065 .db "pause",0 003d2e 3d02 .dw VE_HEAD .set VE_HEAD = VE_PAUSE XT_PAUSE: 003d2f 3dfe .dw PFA_DODEFER1 PFA_PAUSE: 003d30 01a3 .dw ram_pause 003d31 3db3 .dw XT_RDEFERFETCH 003d32 3dbd .dw XT_RDEFERSTORE .dseg 0001a3 ram_pause: .byte 2 .cseg .include "words/cold.asm" ; System ; start up amforth. VE_COLD: 003d33 ff04 .dw $ff04 003d34 6f63 003d35 646c .db "cold" 003d36 3d2a .dw VE_HEAD .set VE_HEAD = VE_COLD XT_COLD: 003d37 3d38 .dw PFA_COLD PFA_COLD: 003d38 b6a4 in_ mcu_boot, MCUSR 003d39 2422 clr zerol 003d3a 2433 clr zeroh 003d3b 24bb clr isrflag 003d3c be24 out_ MCUSR, zerol ; clear RAM 003d3d e0e0 ldi zl, low(ramstart) 003d3e e0f1 ldi zh, high(ramstart) clearloop: 003d3f 9221 st Z+, zerol 003d40 30e0 cpi zl, low(sram_size+ramstart) 003d41 f7e9 brne clearloop 003d42 30fb cpi zh, high(sram_size+ramstart) 003d43 f7d9 brne clearloop ; init first user data area ; allocate space for User Area .dseg 0001a5 ram_user1: .byte SYSUSERSIZE + APPUSERSIZE .cseg 003d44 eae5 ldi zl, low(ram_user1) 003d45 e0f1 ldi zh, high(ram_user1) 003d46 012f movw upl, zl ; init return stack pointer 003d47 ef0f ldi temp0,low(rstackstart) 003d48 bf0d out_ SPL,temp0 003d49 8304 std Z+4, temp0 003d4a e01a ldi temp1,high(rstackstart) 003d4b bf1e out_ SPH,temp1 003d4c 8315 std Z+5, temp1 ; init parameter stack pointer 003d4d eacf ldi yl,low(stackstart) 003d4e 83c6 std Z+6, yl 003d4f e0da ldi yh,high(stackstart) 003d50 83d7 std Z+7, yh ; load Forth IP with starting word 003d51 e5a9 ldi XL, low(PFA_WARM) 003d52 e3bd ldi XH, high(PFA_WARM) ; its a far jump... 003d53 cab0 jmp_ DO_NEXT .include "words/warm.asm" ; System ; initialize amforth further. executes turnkey operation and go to quit .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_WARM: 003d54 ff04 .dw $ff04 003d55 6177 003d56 6d72 .db "warm" 003d57 3d33 .dw VE_HEAD .set VE_HEAD = VE_WARM XT_WARM: 003d58 3800 .dw DO_COLON PFA_WARM: .endif 003d59 0289 .dw XT_INIT_RAM 003d5a 383c .dw XT_DOLITERAL 003d5b 017b .dw XT_NOOP 003d5c 383c .dw XT_DOLITERAL 003d5d 3d2f .dw XT_PAUSE 003d5e 3dde .dw XT_DEFERSTORE 003d5f 08d8 .dw XT_LBRACKET 003d60 3f5b .dw XT_TURNKEY 003d61 3d06 .dw XT_QUIT ; never returns .include "words/handler.asm" ; Exceptions ; USER variable used by catch/throw .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_HANDLER: 003d62 ff07 .dw $ff07 003d63 6168 003d64 646e 003d65 656c 003d66 0072 .db "handler",0 003d67 3d54 .dw VE_HEAD .set VE_HEAD = VE_HANDLER XT_HANDLER: 003d68 3857 .dw PFA_DOUSER PFA_HANDLER: .endif 003d69 000a .dw USER_HANDLER .include "words/catch.asm" ; Exceptions ; execute XT and check for exceptions. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CATCH: 003d6a ff05 .dw $ff05 003d6b 6163 003d6c 6374 003d6d 0068 .db "catch",0 003d6e 3d62 .dw VE_HEAD .set VE_HEAD = VE_CATCH XT_CATCH: 003d6f 3800 .dw DO_COLON PFA_CATCH: .endif ; sp@ >r 003d70 3a8c .dw XT_SP_FETCH 003d71 38fe .dw XT_TO_R ; handler @ >r 003d72 3d68 .dw XT_HANDLER 003d73 3878 .dw XT_FETCH 003d74 38fe .dw XT_TO_R ; rp@ handler ! 003d75 3a75 .dw XT_RP_FETCH 003d76 3d68 .dw XT_HANDLER 003d77 3880 .dw XT_STORE 003d78 3829 .dw XT_EXECUTE ; r> handler ! 003d79 38f5 .dw XT_R_FROM 003d7a 3d68 .dw XT_HANDLER 003d7b 3880 .dw XT_STORE 003d7c 38f5 .dw XT_R_FROM 003d7d 38d8 .dw XT_DROP 003d7e 3953 .dw XT_ZERO 003d7f 381f .dw XT_EXIT .include "words/throw.asm" ; Exceptions ; throw an exception .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_THROW: 003d80 ff05 .dw $ff05 003d81 6874 003d82 6f72 003d83 0077 .db "throw",0 003d84 3d6a .dw VE_HEAD .set VE_HEAD = VE_THROW XT_THROW: 003d85 3800 .dw DO_COLON PFA_THROW: .endif 003d86 38b0 .dw XT_DUP 003d87 3919 .dw XT_ZEROEQUAL 003d88 3835 .dw XT_DOCONDBRANCH 003d89 3d8c DEST(PFA_THROW1) 003d8a 38d8 .dw XT_DROP 003d8b 381f .dw XT_EXIT PFA_THROW1: 003d8c 3d68 .dw XT_HANDLER 003d8d 3878 .dw XT_FETCH 003d8e 3a7f .dw XT_RP_STORE 003d8f 38f5 .dw XT_R_FROM 003d90 3d68 .dw XT_HANDLER 003d91 3880 .dw XT_STORE 003d92 38f5 .dw XT_R_FROM 003d93 38c3 .dw XT_SWAP 003d94 38fe .dw XT_TO_R 003d95 3a95 .dw XT_SP_STORE 003d96 38d8 .dw XT_DROP 003d97 38f5 .dw XT_R_FROM 003d98 381f .dw XT_EXIT .include "words/edefer-fetch.asm" ; System ; does the real defer@ for eeprom defers VE_EDEFERFETCH: 003d99 ff07 .dw $ff07 003d9a 6445 003d9b 6665 003d9c 7265 003d9d 0040 .db "Edefer@",0 003d9e 3d80 .dw VE_HEAD .set VE_HEAD = VE_EDEFERFETCH XT_EDEFERFETCH: 003d9f 3800 .dw DO_COLON PFA_EDEFERFETCH: 003da0 3bca .dw XT_FETCHI 003da1 3b5e .dw XT_FETCHE 003da2 381f .dw XT_EXIT .include "words/edefer-store.asm" ; System ; does the real defer! for eeprom defers VE_EDEFERSTORE: 003da3 ff07 .dw $ff07 003da4 6445 003da5 6665 003da6 7265 003da7 0021 .db "Edefer!",0 003da8 3d99 .dw VE_HEAD .set VE_HEAD = VE_EDEFERSTORE XT_EDEFERSTORE: 003da9 3800 .dw DO_COLON PFA_EDEFERSTORE: 003daa 3bca .dw XT_FETCHI 003dab 3b3a .dw XT_STOREE 003dac 381f .dw XT_EXIT .include "words/rdefer-fetch.asm" ; System ; The defer@ for ram defers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_RDEFERFETCH: 003dad ff07 .dw $ff07 003dae 6452 003daf 6665 003db0 7265 003db1 0040 .db "Rdefer@",0 003db2 3da3 .dw VE_HEAD .set VE_HEAD = VE_RDEFERFETCH XT_RDEFERFETCH: 003db3 3800 .dw DO_COLON PFA_RDEFERFETCH: .endif 003db4 3bca .dw XT_FETCHI 003db5 3878 .dw XT_FETCH 003db6 381f .dw XT_EXIT .include "words/rdefer-store.asm" ; System ; The defer! for ram defers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_RDEFERSTORE: 003db7 ff07 .dw $ff07 003db8 6452 003db9 6665 003dba 7265 003dbb 0021 .db "Rdefer!",0 003dbc 3dad .dw VE_HEAD .set VE_HEAD = VE_RDEFERSTORE XT_RDEFERSTORE: 003dbd 3800 .dw DO_COLON PFA_RDEFERSTORE: .endif 003dbe 3bca .dw XT_FETCHI 003dbf 3880 .dw XT_STORE 003dc0 381f .dw XT_EXIT .include "words/udefer-fetch.asm" ; System ; does the real defer@ for user based defers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDEFERFETCH: 003dc1 ff07 .dw $ff07 003dc2 6455 003dc3 6665 003dc4 7265 003dc5 0040 .db "Udefer@",0 003dc6 3db7 .dw VE_HEAD .set VE_HEAD = VE_UDEFERFETCH XT_UDEFERFETCH: 003dc7 3800 .dw DO_COLON PFA_UDEFERFETCH: .endif 003dc8 3bca .dw XT_FETCHI 003dc9 3b01 .dw XT_UP_FETCH 003dca 399c .dw XT_PLUS 003dcb 3878 .dw XT_FETCH 003dcc 381f .dw XT_EXIT .include "words/udefer-store.asm" ; System ; does the real defer! for user based defers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDEFERSTORE: 003dcd ff07 .dw $ff07 003dce 6455 003dcf 6665 003dd0 7265 003dd1 0021 .db "Udefer!",0 003dd2 3dc1 .dw VE_HEAD .set VE_HEAD = VE_UDEFERSTORE XT_UDEFERSTORE: 003dd3 3800 .dw DO_COLON PFA_UDEFERSTORE: .endif 003dd4 3bca .dw XT_FETCHI 003dd5 3b01 .dw XT_UP_FETCH 003dd6 399c .dw XT_PLUS 003dd7 3880 .dw XT_STORE 003dd8 381f .dw XT_EXIT .include "words/defer-store.asm" ; System ; stores xt1 as the xt to be executed when xt2 is called .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DEFERSTORE: 003dd9 ff06 .dw $ff06 003dda 6564 003ddb 6566 003ddc 2172 .db "defer!" 003ddd 3dcd .dw VE_HEAD .set VE_HEAD = VE_DEFERSTORE XT_DEFERSTORE: 003dde 3800 .dw DO_COLON PFA_DEFERSTORE: .endif 003ddf 3fcf .dw XT_TO_BODY 003de0 38b0 .dw XT_DUP 003de1 01a7 .dw XT_ICELLPLUS 003de2 01a7 .dw XT_ICELLPLUS 003de3 3bca .dw XT_FETCHI 003de4 3829 .dw XT_EXECUTE 003de5 381f .dw XT_EXIT .include "words/defer-fetch.asm" ; System ; returns the XT associated with the given XT .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DEFERFETCH: 003de6 ff06 .dw $ff06 003de7 6564 003de8 6566 003de9 4072 .db "defer@" 003dea 3dd9 .dw VE_HEAD .set VE_HEAD = VE_DEFERFETCH XT_DEFERFETCH: 003deb 3800 .dw DO_COLON PFA_DEFERFETCH: .endif 003dec 3fcf .dw XT_TO_BODY 003ded 38b0 .dw XT_DUP 003dee 01a7 .dw XT_ICELLPLUS 003def 3bca .dw XT_FETCHI 003df0 3829 .dw XT_EXECUTE 003df1 381f .dw XT_EXIT .include "words/do-defer.asm" ; System ; runtime of defer VE_DODEFER: 003df2 ff07 .dw $ff07 003df3 6428 003df4 6665 003df5 7265 003df6 0029 .db "(defer)", 0 003df7 3de6 .dw VE_HEAD .set VE_HEAD = VE_DODEFER XT_DODEFER: 003df8 3800 .dw DO_COLON PFA_DODEFER: 003df9 0720 .dw XT_DOCREATE 003dfa 0880 .dw XT_REVEAL 003dfb 0743 .dw XT_COMPILE 003dfc 3dfe .dw PFA_DODEFER1 003dfd 381f .dw XT_EXIT PFA_DODEFER1: 003dfe 940e 0899 call_ DO_DODOES 003e00 38b0 .dw XT_DUP 003e01 01a7 .dw XT_ICELLPLUS 003e02 3bca .dw XT_FETCHI 003e03 3829 .dw XT_EXECUTE 003e04 3829 .dw XT_EXECUTE 003e05 381f .dw XT_EXIT ; : (defer) dup i-cell+ @i execute execute ; .include "words/u-dot.asm" ; Numeric IO ; unsigned PNO with single cell numbers .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDOT: 003e06 ff02 .dw $ff02 003e07 2e75 .db "u." 003e08 3df2 .dw VE_HEAD .set VE_HEAD = VE_UDOT XT_UDOT: 003e09 3800 .dw DO_COLON PFA_UDOT: .endif 003e0a 3953 .dw XT_ZERO 003e0b 0374 .dw XT_UDDOT 003e0c 381f .dw XT_EXIT ; : u. ( us -- ) 0 ud. ; .include "words/u-dot-r.asm" ; Numeric IO ; unsigned PNO with single cells numbers, right aligned in width w .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_UDOTR: 003e0d ff03 .dw $ff03 003e0e 2e75 003e0f 0072 .db "u.r",0 003e10 3e06 .dw VE_HEAD .set VE_HEAD = VE_UDOTR XT_UDOTR: 003e11 3800 .dw DO_COLON PFA_UDOTR: .endif 003e12 3953 .dw XT_ZERO 003e13 38c3 .dw XT_SWAP 003e14 037d .dw XT_UDDOTR 003e15 381f .dw XT_EXIT ; : u.r ( s n -- ) 0 swap ud.r ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; .include "words/uslashmod.asm" ; Arithmetics ; unsigned division with remainder VE_USLASHMOD: 003e16 ff05 .dw $ff05 003e17 2f75 003e18 6f6d 003e19 0064 .db "u/mod",0 003e1a 3e0d .dw VE_HEAD .set VE_HEAD = VE_USLASHMOD XT_USLASHMOD: 003e1b 3800 .dw DO_COLON PFA_USLASHMOD: 003e1c 38fe .dw XT_TO_R 003e1d 3953 .dw XT_ZERO 003e1e 38f5 .dw XT_R_FROM 003e1f 39c1 .dw XT_UMSLASHMOD 003e20 381f .dw XT_EXIT .include "words/negate.asm" ; Logic ; 2-complement VE_NEGATE: 003e21 ff06 .dw $ff06 003e22 656e 003e23 6167 003e24 6574 .db "negate" 003e25 3e16 .dw VE_HEAD .set VE_HEAD = VE_NEGATE XT_NEGATE: 003e26 3800 .dw DO_COLON PFA_NEGATE: 003e27 39fc .dw XT_INVERT 003e28 3a2e .dw XT_1PLUS 003e29 381f .dw XT_EXIT .include "words/slash.asm" ; Arithmetics ; divide n1 by n2. giving the quotient .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SLASH: 003e2a ff01 .dw $ff01 003e2b 002f .db "/",0 003e2c 3e21 .dw VE_HEAD .set VE_HEAD = VE_SLASH XT_SLASH: 003e2d 3800 .dw DO_COLON PFA_SLASH: .endif 003e2e 3c48 .dw XT_SLASHMOD 003e2f 38ef .dw XT_NIP 003e30 381f .dw XT_EXIT .include "words/mod.asm" ; Arithmetics ; divide n1 by n2 giving the remainder n3 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_MOD: 003e31 ff03 .dw $ff03 003e32 6f6d 003e33 0064 .db "mod",0 003e34 3e2a .dw VE_HEAD .set VE_HEAD = VE_MOD XT_MOD: 003e35 3800 .dw DO_COLON PFA_MOD: .endif 003e36 3c48 .dw XT_SLASHMOD 003e37 38d8 .dw XT_DROP 003e38 381f .dw XT_EXIT .include "words/min.asm" ; Compare ; compare two values leave the smaller one .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_MIN: 003e39 ff03 .dw $ff03 003e3a 696d 003e3b 006e .db "min",0 003e3c 3e31 .dw VE_HEAD .set VE_HEAD = VE_MIN XT_MIN: 003e3d 3800 .dw DO_COLON PFA_MIN: .endif 003e3e 3ec8 .dw XT_2DUP 003e3f 3977 .dw XT_GREATER 003e40 3835 .dw XT_DOCONDBRANCH 003e41 3e43 DEST(PFA_MIN1) 003e42 38c3 .dw XT_SWAP PFA_MIN1: 003e43 38d8 .dw XT_DROP 003e44 381f .dw XT_EXIT .include "words/max.asm" ; Compare ; compare two values, leave the bigger one .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_MAX: 003e45 ff03 .dw $ff03 003e46 616d 003e47 0078 .db "max",0 003e48 3e39 .dw VE_HEAD .set VE_HEAD = VE_MAX XT_MAX: 003e49 3800 .dw DO_COLON PFA_MAX: .endif 003e4a 3ec8 .dw XT_2DUP 003e4b 396d .dw XT_LESS 003e4c 3835 .dw XT_DOCONDBRANCH 003e4d 3e4f DEST(PFA_MAX1) 003e4e 38c3 .dw XT_SWAP PFA_MAX1: 003e4f 38d8 .dw XT_DROP 003e50 381f .dw XT_EXIT .include "words/within.asm" ; Compare ; check if n is within min..max .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_WITHIN: 003e51 ff06 .dw $ff06 003e52 6977 003e53 6874 003e54 6e69 .db "within" 003e55 3e45 .dw VE_HEAD .set VE_HEAD = VE_WITHIN XT_WITHIN: 003e56 3800 .dw DO_COLON PFA_WITHIN: .endif 003e57 38ce .dw XT_OVER 003e58 3992 .dw XT_MINUS 003e59 38fe .dw XT_TO_R 003e5a 3992 .dw XT_MINUS 003e5b 38f5 .dw XT_R_FROM 003e5c 395b .dw XT_ULESS 003e5d 381f .dw XT_EXIT .include "words/show-wordlist.asm" ; Tools ; prints the name of the words in a wordlist .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SHOWWORDLIST: 003e5e ff0d .dw $ff0d 003e5f 6873 003e60 776f 003e61 772d 003e62 726f 003e63 6c64 003e64 7369 003e65 0074 .db "show-wordlist",0 003e66 3e51 .dw VE_HEAD .set VE_HEAD = VE_SHOWWORDLIST XT_SHOWWORDLIST: 003e67 3800 .dw DO_COLON PFA_SHOWWORDLIST: .endif 003e68 383c .dw XT_DOLITERAL 003e69 3e6d .dw XT_SHOWWORD 003e6a 38c3 .dw XT_SWAP 003e6b 06c1 .dw XT_TRAVERSEWORDLIST 003e6c 381f .dw XT_EXIT .if cpu_msp430==1 .endif .if cpu_avr8==1 XT_SHOWWORD: 003e6d 3800 .dw DO_COLON PFA_SHOWWORD: .endif 003e6e 06dc .dw XT_NAME2STRING 003e6f 03ea .dw XT_ITYPE 003e70 3fad .dw XT_SPACE ; ( -- addr n) 003e71 394a .dw XT_TRUE 003e72 381f .dw XT_EXIT .include "words/words.asm" ; Tools ; prints a list of all (visible) words in the dictionary .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_WORDS: 003e73 ff05 .dw $ff05 003e74 6f77 003e75 6472 003e76 0073 .db "words",0 003e77 3e5e .dw VE_HEAD .set VE_HEAD = VE_WORDS XT_WORDS: 003e78 3800 .dw DO_COLON PFA_WORDS: .endif 003e79 383c .dw XT_DOLITERAL 003e7a 006e .dw CFG_ORDERLISTLEN+2 003e7b 3b5e .dw XT_FETCHE 003e7c 3e67 .dw XT_SHOWWORDLIST 003e7d 381f .dw XT_EXIT .include "words/dot-quote.asm" ; Compiler ; compiles string into dictionary to be printed at runtime .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DOTSTRING: 003e7e 0002 .dw $0002 003e7f 222e .db ".",$22 003e80 3e73 .dw VE_HEAD .set VE_HEAD = VE_DOTSTRING XT_DOTSTRING: 003e81 3800 .dw DO_COLON PFA_DOTSTRING: .endif 003e82 3e89 .dw XT_SQUOTE 003e83 0743 .dw XT_COMPILE 003e84 03ea .dw XT_ITYPE 003e85 381f .dw XT_EXIT .include "words/squote.asm" ; Compiler ; compiles a string to flash, at runtime leaves ( -- flash-addr count) on stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SQUOTE: 003e86 0002 .dw $0002 003e87 2273 .db "s",$22 003e88 3e7e .dw VE_HEAD .set VE_HEAD = VE_SQUOTE XT_SQUOTE: 003e89 3800 .dw DO_COLON PFA_SQUOTE: .endif 003e8a 383c .dw XT_DOLITERAL 003e8b 0022 .dw 34 ; 0x22 003e8c 0575 .dw XT_PARSE ; ( -- addr n) 003e8d 3eb6 .dw XT_STATE 003e8e 3878 .dw XT_FETCH 003e8f 3835 .dw XT_DOCONDBRANCH 003e90 3e92 DEST(PFA_SQUOTE1) 003e91 076f .dw XT_SLITERAL PFA_SQUOTE1: 003e92 381f .dw XT_EXIT .include "words/fill.asm" ; Memory ; fill u bytes memory beginning at a-addr with character c VE_FILL: 003e93 ff04 .dw $ff04 003e94 6966 003e95 6c6c .db "fill" 003e96 3e86 .dw VE_HEAD .set VE_HEAD = VE_FILL XT_FILL: 003e97 3800 .dw DO_COLON PFA_FILL: 003e98 38e0 .dw XT_ROT 003e99 38e0 .dw XT_ROT 003e9a 38b8 003e9b 3835 .dw XT_QDUP,XT_DOCONDBRANCH 003e9c 3ea4 DEST(PFA_FILL2) 003e9d 3f98 .dw XT_BOUNDS 003e9e 3a9a .dw XT_DODO PFA_FILL1: 003e9f 38b0 .dw XT_DUP 003ea0 3aab .dw XT_I 003ea1 388c .dw XT_CSTORE ; ( -- c c-addr) 003ea2 3ac8 .dw XT_DOLOOP 003ea3 3e9f .dw PFA_FILL1 PFA_FILL2: 003ea4 38d8 .dw XT_DROP 003ea5 381f .dw XT_EXIT .include "words/f_cpu.asm" ; System ; put the cpu frequency in Hz on stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_F_CPU: 003ea6 ff05 .dw $ff05 003ea7 5f66 003ea8 7063 003ea9 0075 .db "f_cpu",0 003eaa 3e93 .dw VE_HEAD .set VE_HEAD = VE_F_CPU XT_F_CPU: 003eab 3800 .dw DO_COLON PFA_F_CPU: .endif 003eac 383c .dw XT_DOLITERAL 003ead 2400 .dw (F_CPU % 65536) 003eae 383c .dw XT_DOLITERAL 003eaf 00f4 .dw (F_CPU / 65536) 003eb0 381f .dw XT_EXIT .include "words/state.asm" ; System Variable ; system state VE_STATE: 003eb1 ff05 .dw $ff05 003eb2 7473 003eb3 7461 003eb4 0065 .db "state",0 003eb5 3ea6 .dw VE_HEAD .set VE_HEAD = VE_STATE XT_STATE: 003eb6 3847 .dw PFA_DOVARIABLE PFA_STATE: 003eb7 01d1 .dw ram_state .dseg 0001d1 ram_state: .byte 2 .include "words/base.asm" ; Numeric IO ; location of the cell containing the number conversion radix .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BASE: 003eb8 ff04 .dw $ff04 003eb9 6162 003eba 6573 .db "base" 003ebb 3eb1 .dw VE_HEAD .set VE_HEAD = VE_BASE XT_BASE: 003ebc 3857 .dw PFA_DOUSER PFA_BASE: .endif 003ebd 000c .dw USER_BASE .include "words/cells.asm" ; Arithmetics ; n2 is the size in address units of n1 cells VE_CELLS: 003ebe ff05 .dw $ff05 003ebf 6563 003ec0 6c6c 003ec1 0073 .db "cells",0 003ec2 3eb8 .dw VE_HEAD .set VE_HEAD = VE_CELLS XT_CELLS: 003ec3 3a0b .dw PFA_2STAR .include "words/2dup.asm" ; Stack ; Duplicate the 2 top elements .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_2DUP: 003ec4 ff04 .dw $ff04 003ec5 6432 003ec6 7075 .db "2dup" 003ec7 3ebe .dw VE_HEAD .set VE_HEAD = VE_2DUP XT_2DUP: 003ec8 3800 .dw DO_COLON PFA_2DUP: .endif 003ec9 38ce .dw XT_OVER 003eca 38ce .dw XT_OVER 003ecb 381f .dw XT_EXIT .include "words/2drop.asm" ; Stack ; Remove the 2 top elements .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_2DROP: 003ecc ff05 .dw $ff05 003ecd 6432 003ece 6f72 003ecf 0070 .db "2drop",0 003ed0 3ec4 .dw VE_HEAD .set VE_HEAD = VE_2DROP XT_2DROP: 003ed1 3800 .dw DO_COLON PFA_2DROP: .endif 003ed2 38d8 .dw XT_DROP 003ed3 38d8 .dw XT_DROP 003ed4 381f .dw XT_EXIT .include "words/tuck.asm" ; Stack ; Copy the first (top) stack item below the second stack item. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TUCK: 003ed5 ff04 .dw $ff04 003ed6 7574 003ed7 6b63 .db "tuck" 003ed8 3ecc .dw VE_HEAD .set VE_HEAD = VE_TUCK XT_TUCK: 003ed9 3800 .dw DO_COLON PFA_TUCK: .endif 003eda 38c3 .dw XT_SWAP 003edb 38ce .dw XT_OVER 003edc 381f .dw XT_EXIT .include "words/to-in.asm" ; System Variable ; pointer to current read position in input buffer .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TO_IN: 003edd ff03 .dw $ff03 003ede 693e 003edf 006e .db ">in",0 003ee0 3ed5 .dw VE_HEAD .set VE_HEAD = VE_TO_IN XT_TO_IN: 003ee1 3857 .dw PFA_DOUSER PFA_TO_IN: .endif 003ee2 0018 .dw USER_TO_IN .include "words/pad.asm" ; System Variable ; Address of the temporary scratch buffer. .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_PAD: 003ee3 ff03 .dw $ff03 003ee4 6170 003ee5 0064 .db "pad",0 003ee6 3edd .dw VE_HEAD .set VE_HEAD = VE_PAD XT_PAD: 003ee7 3800 .dw DO_COLON PFA_PAD: .endif 003ee8 3f22 .dw XT_HERE 003ee9 383c .dw XT_DOLITERAL 003eea 0028 .dw 40 003eeb 399c .dw XT_PLUS 003eec 381f .dw XT_EXIT .include "words/emit.asm" ; Character IO ; fetch the emit vector and execute it. should emit a character from TOS .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_EMIT: 003eed ff04 .dw $ff04 003eee 6d65 003eef 7469 .db "emit" 003ef0 3ee3 .dw VE_HEAD .set VE_HEAD = VE_EMIT XT_EMIT: 003ef1 3dfe .dw PFA_DODEFER1 PFA_EMIT: .endif 003ef2 000e .dw USER_EMIT 003ef3 3dc7 .dw XT_UDEFERFETCH 003ef4 3dd3 .dw XT_UDEFERSTORE .include "words/emitq.asm" ; Character IO ; fetch emit? vector and execute it. should return the ready-to-send condition .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_EMITQ: 003ef5 ff05 .dw $ff05 003ef6 6d65 003ef7 7469 003ef8 003f .db "emit?",0 003ef9 3eed .dw VE_HEAD .set VE_HEAD = VE_EMITQ XT_EMITQ: 003efa 3dfe .dw PFA_DODEFER1 PFA_EMITQ: .endif 003efb 0010 .dw USER_EMITQ 003efc 3dc7 .dw XT_UDEFERFETCH 003efd 3dd3 .dw XT_UDEFERSTORE .include "words/key.asm" ; Character IO ; fetch key vector and execute it, should leave a single character on TOS .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_KEY: 003efe ff03 .dw $ff03 003eff 656b 003f00 0079 .db "key",0 003f01 3ef5 .dw VE_HEAD .set VE_HEAD = VE_KEY XT_KEY: 003f02 3dfe .dw PFA_DODEFER1 PFA_KEY: .endif 003f03 0012 .dw USER_KEY 003f04 3dc7 .dw XT_UDEFERFETCH 003f05 3dd3 .dw XT_UDEFERSTORE .include "words/keyq.asm" ; Character IO ; fetch key? vector and execute it. should turn on key sender, if it is disabled/stopped .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_KEYQ: 003f06 ff04 .dw $ff04 003f07 656b 003f08 3f79 .db "key?" 003f09 3efe .dw VE_HEAD .set VE_HEAD = VE_KEYQ XT_KEYQ: 003f0a 3dfe .dw PFA_DODEFER1 PFA_KEYQ: .endif 003f0b 0014 .dw USER_KEYQ 003f0c 3dc7 .dw XT_UDEFERFETCH 003f0d 3dd3 .dw XT_UDEFERSTORE .include "words/dp.asm" ; System Value ; address of the next free dictionary cell VE_DP: 003f0e ff02 .dw $ff02 003f0f 7064 .db "dp" 003f10 3f06 .dw VE_HEAD .set VE_HEAD = VE_DP XT_DP: 003f11 386e .dw PFA_DOVALUE1 PFA_DP: 003f12 0058 .dw CFG_DP 003f13 3d9f .dw XT_EDEFERFETCH 003f14 3da9 .dw XT_EDEFERSTORE .include "words/ehere.asm" ; System Value ; address of the next free address in eeprom VE_EHERE: 003f15 ff05 .dw $ff05 003f16 6865 003f17 7265 003f18 0065 .db "ehere",0 003f19 3f0e .dw VE_HEAD .set VE_HEAD = VE_EHERE XT_EHERE: 003f1a 386e .dw PFA_DOVALUE1 PFA_EHERE: 003f1b 005c .dw EE_EHERE 003f1c 3d9f .dw XT_EDEFERFETCH 003f1d 3da9 .dw XT_EDEFERSTORE .include "words/here.asm" ; System Value ; address of the next free data space (RAM) cell VE_HERE: 003f1e ff04 .dw $ff04 003f1f 6568 003f20 6572 .db "here" 003f21 3f15 .dw VE_HEAD .set VE_HEAD = VE_HERE XT_HERE: 003f22 386e .dw PFA_DOVALUE1 PFA_HERE: 003f23 005a .dw EE_HERE 003f24 3d9f .dw XT_EDEFERFETCH 003f25 3da9 .dw XT_EDEFERSTORE .include "words/allot.asm" ; System ; allocate or release memory in RAM VE_ALLOT: 003f26 ff05 .dw $ff05 003f27 6c61 003f28 6f6c 003f29 0074 .db "allot",0 003f2a 3f1e .dw VE_HEAD .set VE_HEAD = VE_ALLOT XT_ALLOT: 003f2b 3800 .dw DO_COLON PFA_ALLOT: 003f2c 3f22 .dw XT_HERE 003f2d 399c .dw XT_PLUS 003f2e 0195 .dw XT_DOTO 003f2f 3f23 .dw PFA_HERE 003f30 381f .dw XT_EXIT .include "words/bin.asm" ; Numeric IO ; set base for numeric conversion to 10 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BIN: 003f31 ff03 .dw $ff03 003f32 6962 003f33 006e .db "bin",0 003f34 3f26 .dw VE_HEAD .set VE_HEAD = VE_BIN XT_BIN: 003f35 3800 .dw DO_COLON PFA_BIN: .endif 003f36 3fea .dw XT_TWO 003f37 3ebc .dw XT_BASE 003f38 3880 .dw XT_STORE 003f39 381f .dw XT_EXIT .include "words/decimal.asm" ; Numeric IO ; set base for numeric conversion to 10 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_DECIMAL: 003f3a ff07 .dw $ff07 003f3b 6564 003f3c 6963 003f3d 616d 003f3e 006c .db "decimal",0 003f3f 3f31 .dw VE_HEAD .set VE_HEAD = VE_DECIMAL XT_DECIMAL: 003f40 3800 .dw DO_COLON PFA_DECIMAL: .endif 003f41 383c .dw XT_DOLITERAL 003f42 000a .dw 10 003f43 3ebc .dw XT_BASE 003f44 3880 .dw XT_STORE 003f45 381f .dw XT_EXIT .include "words/hex.asm" ; Numeric IO ; set base for numeric conversion to 10 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_HEX: 003f46 ff03 .dw $ff03 003f47 6568 003f48 0078 .db "hex",0 003f49 3f3a .dw VE_HEAD .set VE_HEAD = VE_HEX XT_HEX: 003f4a 3800 .dw DO_COLON PFA_HEX: .endif 003f4b 383c .dw XT_DOLITERAL 003f4c 0010 .dw 16 003f4d 3ebc .dw XT_BASE 003f4e 3880 .dw XT_STORE 003f4f 381f .dw XT_EXIT .include "words/bl.asm" ; Character IO ; put ascii code of the blank to the stack .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BL: 003f50 ff02 .dw $ff02 003f51 6c62 .db "bl" 003f52 3f46 .dw VE_HEAD .set VE_HEAD = VE_BL XT_BL: 003f53 3847 .dw PFA_DOVARIABLE PFA_BL: .endif 003f54 0020 .dw 32 .include "words/turnkey.asm" ; System Value ; Deferred action during startup/reset VE_TURNKEY: 003f55 ff07 .dw $ff07 003f56 7574 003f57 6e72 003f58 656b 003f59 0079 .db "turnkey",0 003f5a 3f50 .dw VE_HEAD .set VE_HEAD = VE_TURNKEY XT_TURNKEY: 003f5b 3dfe .dw PFA_DODEFER1 PFA_TURNKEY: 003f5c 0064 .dw CFG_TURNKEY 003f5d 3d9f .dw XT_EDEFERFETCH 003f5e 3da9 .dw XT_EDEFERSTORE .include "words/to-upper.asm" ; String ; if c is a lowercase letter convert it to uppercase .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TOUPPER: 003f5f ff07 .dw $ff07 003f60 6f74 003f61 7075 003f62 6570 003f63 0072 .db "toupper",0 003f64 3f55 .dw VE_HEAD .set VE_HEAD = VE_TOUPPER XT_TOUPPER: 003f65 3800 .dw DO_COLON PFA_TOUPPER: .endif 003f66 38b0 .dw XT_DUP 003f67 383c .dw XT_DOLITERAL 003f68 0061 .dw 'a' 003f69 383c .dw XT_DOLITERAL 003f6a 007b .dw 'z'+1 003f6b 3e56 .dw XT_WITHIN 003f6c 3835 .dw XT_DOCONDBRANCH 003f6d 3f71 DEST(PFA_TOUPPER0) 003f6e 383c .dw XT_DOLITERAL 003f6f 00df .dw 223 ; inverse of 0x20: 0xdf 003f70 3a12 .dw XT_AND PFA_TOUPPER0: 003f71 381f .dw XT_EXIT .include "words/to-lower.asm" ; String ; if C is an uppercase letter convert it to lowercase .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TOLOWER: 003f72 ff07 .dw $ff07 003f73 6f74 003f74 6f6c 003f75 6577 003f76 0072 .db "tolower",0 003f77 3f5f .dw VE_HEAD .set VE_HEAD = VE_TOLOWER XT_TOLOWER: 003f78 3800 .dw DO_COLON PFA_TOLOWER: .endif 003f79 38b0 .dw XT_DUP 003f7a 383c .dw XT_DOLITERAL 003f7b 0041 .dw 'A' 003f7c 383c .dw XT_DOLITERAL 003f7d 005b .dw 'Z'+1 003f7e 3e56 .dw XT_WITHIN 003f7f 3835 .dw XT_DOCONDBRANCH 003f80 3f84 DEST(PFA_TOLOWER0) 003f81 383c .dw XT_DOLITERAL 003f82 0020 .dw 32 003f83 3a1b .dw XT_OR PFA_TOLOWER0: 003f84 381f .dw XT_EXIT .include "words/q-stack.asm" ; Tools ; check data stack depth and exit to quit if underrun .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_QSTACK: 003f85 ff06 .dw $ff06 003f86 733f 003f87 6174 003f88 6b63 .db "?stack" 003f89 3f72 .dw VE_HEAD .set VE_HEAD = VE_QSTACK XT_QSTACK: 003f8a 3800 .dw DO_COLON PFA_QSTACK: .endif 003f8b 05d4 .dw XT_DEPTH 003f8c 3920 .dw XT_ZEROLESS 003f8d 3835 .dw XT_DOCONDBRANCH 003f8e 3f92 DEST(PFA_QSTACK1) 003f8f 383c .dw XT_DOLITERAL 003f90 fffc .dw -4 003f91 3d85 .dw XT_THROW PFA_QSTACK1: 003f92 381f .dw XT_EXIT .include "words/bounds.asm" ; Tools ; convert a string to an address range .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_BOUNDS: 003f93 ff06 .dw $ff06 003f94 6f62 003f95 6e75 003f96 7364 .db "bounds" 003f97 3f85 .dw VE_HEAD .set VE_HEAD = VE_BOUNDS XT_BOUNDS: 003f98 3800 .dw DO_COLON PFA_BOUNDS: .endif 003f99 38ce .dw XT_OVER 003f9a 399c .dw XT_PLUS 003f9b 38c3 .dw XT_SWAP 003f9c 381f .dw XT_EXIT .include "words/cr.asm" ; Character IO ; cause subsequent output appear at the beginning of the next line .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_CR: 003f9d ff02 .dw 0xff02 003f9e 7263 .db "cr" 003f9f 3f93 .dw VE_HEAD .set VE_HEAD = VE_CR XT_CR: 003fa0 3800 .dw DO_COLON PFA_CR: .endif 003fa1 383c .dw XT_DOLITERAL 003fa2 000d .dw 13 003fa3 3ef1 .dw XT_EMIT 003fa4 383c .dw XT_DOLITERAL 003fa5 000a .dw 10 003fa6 3ef1 .dw XT_EMIT 003fa7 381f .dw XT_EXIT .include "words/space.asm" ; Character IO ; emits a space (bl) .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SPACE: 003fa8 ff05 .dw $ff05 003fa9 7073 003faa 6361 003fab 0065 .db "space",0 003fac 3f9d .dw VE_HEAD .set VE_HEAD = VE_SPACE XT_SPACE: 003fad 3800 .dw DO_COLON PFA_SPACE: .endif 003fae 3f53 .dw XT_BL 003faf 3ef1 .dw XT_EMIT 003fb0 381f .dw XT_EXIT .include "words/spaces.asm" ; Character IO ; emits n space(s) (bl) .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_SPACES: 003fb1 ff06 .dw $ff06 003fb2 7073 003fb3 6361 003fb4 7365 .db "spaces" 003fb5 3fa8 .dw VE_HEAD .set VE_HEAD = VE_SPACES XT_SPACES: 003fb6 3800 .dw DO_COLON PFA_SPACES: .endif ;C SPACES n -- output n spaces ; BEGIN DUP 0> WHILE SPACE 1- REPEAT DROP ; 003fb7 3953 003fb8 3e49 .DW XT_ZERO, XT_MAX 003fb9 38b0 003fba 3835 SPCS1: .DW XT_DUP,XT_DOCONDBRANCH 003fbb 3fc0 DEST(SPCS2) 003fbc 3fad 003fbd 3a34 003fbe 382e .DW XT_SPACE,XT_1MINUS,XT_DOBRANCH 003fbf 3fb9 DEST(SPCS1) 003fc0 38d8 003fc1 381f SPCS2: .DW XT_DROP,XT_EXIT .include "words/s-to-d.asm" ; Conversion ; extend (signed) single cell value to double cell .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_S2D: 003fc2 ff03 .dw $ff03 003fc3 3e73 003fc4 0064 .db "s>d",0 003fc5 3fb1 .dw VE_HEAD .set VE_HEAD = VE_S2D XT_S2D: 003fc6 3800 .dw DO_COLON PFA_S2D: .endif 003fc7 38b0 .dw XT_DUP 003fc8 3920 .dw XT_ZEROLESS 003fc9 381f .dw XT_EXIT .include "words/to-body.asm" ; Core ; get body from XT VE_TO_BODY: 003fca ff05 .dw $ff05 003fcb 623e 003fcc 646f 003fcd 0079 .db ">body",0 003fce 3fc2 .dw VE_HEAD .set VE_HEAD = VE_TO_BODY XT_TO_BODY: 003fcf 3a2f .dw PFA_1PLUS .elif AMFORTH_NRWW_SIZE>2000 .else .endif ; now colon words ;;;;;;;;;;;;;;;;;;;;;;;; .include "words/2literal.asm" ; Compiler ; compile a cell pair literal in colon definitions .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_2LITERAL: 003fd0 0008 .dw $0008 003fd1 6c32 003fd2 7469 003fd3 7265 003fd4 6c61 .db "2literal" 003fd5 3fca .dw VE_HEAD .set VE_HEAD = VE_2LITERAL XT_2LITERAL: 003fd6 3800 .dw DO_COLON PFA_2LITERAL: .endif 003fd7 38c3 .dw XT_SWAP 003fd8 0764 .dw XT_LITERAL 003fd9 0764 .dw XT_LITERAL 003fda 381f .dw XT_EXIT .include "words/equal.asm" ; Compare ; compares two values for equality VE_EQUAL: 003fdb ff01 .dw $ff01 003fdc 003d .db "=",0 003fdd 3fd0 .dw VE_HEAD .set VE_HEAD = VE_EQUAL XT_EQUAL: 003fde 3800 .dw DO_COLON PFA_EQUAL: 003fdf 3992 .dw XT_MINUS 003fe0 3919 .dw XT_ZEROEQUAL 003fe1 381f .dw XT_EXIT .include "words/num-constants.asm" .endif .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_ONE: 003fe2 ff01 .dw $ff01 003fe3 0031 .db "1",0 003fe4 3fdb .dw VE_HEAD .set VE_HEAD = VE_ONE XT_ONE: 003fe5 3847 .dw PFA_DOVARIABLE PFA_ONE: .endif 003fe6 0001 .DW 1 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_TWO: 003fe7 ff01 .dw $ff01 003fe8 0032 .db "2",0 003fe9 3fe2 .dw VE_HEAD .set VE_HEAD = VE_TWO XT_TWO: 003fea 3847 .dw PFA_DOVARIABLE PFA_TWO: .endif 003feb 0002 .DW 2 .if cpu_msp430==1 .endif .if cpu_avr8==1 VE_MINUSONE: 003fec ff02 .dw $ff02 003fed 312d .db "-1" 003fee 3fe7 .dw VE_HEAD .set VE_HEAD = VE_MINUSONE XT_MINUSONE: 003fef 3847 .dw PFA_DOVARIABLE PFA_MINUSONE: .endif 003ff0 ffff .DW -1 .include "dict_appl_core.inc" ; do not delete it! .set flashlast = pc .if (pc>FLASHEND) .endif .dseg ; define a label for the 1st free ram address HERESTART: .eseg .include "amforth-eeprom.inc" 000056 ff ff ; some configs 000058 a1 0a CFG_DP: .dw DPSTART ; Dictionary Pointer 00005a d3 01 EE_HERE: .dw HERESTART ; Memory Allocation 00005c b0 00 EE_EHERE: .dw EHERESTART ; EEProm Memory Allocation 00005e b5 09 CFG_WLSCOPE: .dw XT_GET_CURRENT ; default wordlist scope 000060 7e 00 CFG_FORTHRECOGNIZER: .dw CFG_RECOGNIZERLISTLEN ; Recognizer word set ; LEAVE stack is between data stack and return stack. 000062 b0 0a CFG_LP0: .dw stackstart+1 000064 93 0a CFG_TURNKEY: .dw XT_APPLTURNKEY ; TURNKEY 000066 e6 02 CFG_ENVIRONMENT:.dw VE_ENVHEAD ; environmental queries 000068 6a 00 CFG_CURRENT: .dw CFG_FORTHWORDLIST ; forth-wordlist 00006a ec 3f CFG_FORTHWORDLIST:.dw VE_HEAD ; pre-defined (compiled in) wordlist CFG_ORDERLISTLEN: 00006c 01 00 .dw 1 CFG_ORDERLIST: ; list of wordlist id, exactly numwordlist entries 00006e 6a 00 .dw CFG_FORTHWORDLIST ; get/set-order 000070 .byte (NUMWORDLISTS-1)*CELLSIZE ; one slot is already used CFG_RECOGNIZERLISTLEN: 00007e 02 00 .dw 2 CFG_RECOGNIZERLIST: 000080 57 06 .dw XT_REC_FIND 000082 43 06 .dw XT_REC_NUM 000084 .byte (NUMRECOGNIZERS-2)*CELLSIZE ; two slots are already used EE_STOREI: 000088 7d 3b .dw XT_DO_STOREI ; Store a cell into flash ; MARKER saves everything up to here. Nothing beyond gets saved EE_MARKER: 00008a 8a 00 .dw EE_MARKER ; default user area EE_INITUSER: 00008c 00 00 .dw 0 ; USER_STATE 00008e 00 00 .dw 0 ; USER_FOLLOWER 000090 ff 0a .dw rstackstart ; USER_RP 000092 af 0a .dw stackstart ; USER_SP0 000094 af 0a .dw stackstart ; USER_SP 000096 00 00 .dw 0 ; USER_HANDLER 000098 0a 00 .dw 10 ; USER_BASE 00009a c5 00 .dw XT_TX ; USER_EMIT 00009c d3 00 .dw XT_TXQ ; USER_EMITQ 00009e 9a 00 .dw XT_RX ; USER_KEY 0000a0 b5 00 .dw XT_RXQ ; USER_KEYQ 0000a2 5e 02 .dw XT_SOURCETIB ; USER_SOURCE 0000a4 00 00 .dw 0 ; USER_G_IN 0000a6 4b 02 .dw XT_REFILLTIB ; USER_REFILL 0000a8 c8 3c .dw XT_DEFAULT_PROMPTOK 0000aa e7 3c .dw XT_DEFAULT_PROMPTERROR 0000ac d7 3c .dw XT_DEFAULT_PROMPTREADY ; calculate baud rate error .equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; smart round .equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; effective baud rate .equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; error in pro mille .if ((BAUD_ERROR>BAUD_MAXERROR) || (BAUD_ERROR<-BAUD_MAXERROR)) .endif EE_UBRRVAL: 0000ae 19 00 .dw UBRR_VAL ; BAUDRATE ; 1st free address in EEPROM. EHERESTART: .cseg RESOURCE USE INFORMATION ------------------------ Notice: The register and instruction counts are symbol table hit counts, and hence implicitly used resources are not counted, eg, the 'lpm' instruction without operands implicitly uses r0 and z, none of which are counted. x,y,z are separate entities in the symbol table and are counted separately from r26..r31 here. .dseg memory usage only counts static data declared with .byte "ATmega32U4" register use summary: r0 : 25 r1 : 5 r2 : 9 r3 : 12 r4 : 4 r5 : 1 r6 : 0 r7 : 0 r8 : 0 r9 : 0 r10: 1 r11: 6 r12: 0 r13: 0 r14: 22 r15: 20 r16: 78 r17: 57 r18: 52 r19: 37 r20: 13 r21: 11 r22: 11 r23: 3 r24: 187 r25: 133 r26: 28 r27: 17 r28: 7 r29: 4 r30: 78 r31: 40 x : 4 y : 203 z : 41 Registers used: 29 out of 35 (82.9%) "ATmega32U4" instruction use summary: .lds : 0 .sts : 0 adc : 22 add : 17 adiw : 17 and : 4 andi : 3 asr : 2 bclr : 0 bld : 0 brbc : 2 brbs : 7 brcc : 2 brcs : 1 break : 0 breq : 6 brge : 1 brhc : 0 brhs : 0 brid : 0 brie : 0 brlo : 1 brlt : 3 brmi : 3 brne : 13 brpl : 0 brsh : 0 brtc : 0 brts : 0 brvc : 0 brvs : 2 bset : 0 bst : 0 call : 2 cbi : 0 cbr : 0 clc : 1 clh : 0 cli : 5 cln : 0 clr : 13 cls : 0 clt : 0 clv : 0 clz : 0 com : 14 cp : 11 cpc : 10 cpi : 2 cpse : 0 dec : 10 eor : 3 fmul : 0 fmuls : 0 fmulsu: 0 icall : 0 ijmp : 1 in : 14 inc : 3 jmp : 7 ld : 136 ldd : 4 ldi : 27 lds : 1 lpm : 16 lsl : 14 lsr : 2 mov : 15 movw : 65 mul : 5 muls : 1 mulsu : 2 neg : 0 nop : 0 or : 9 ori : 1 out : 16 pop : 45 push : 39 rcall : 55 ret : 6 reti : 1 rjmp : 103 rol : 23 ror : 5 sbc : 9 sbci : 3 sbi : 3 sbic : 3 sbis : 0 sbiw : 7 sbr : 0 sbrc : 4 sbrs : 3 sec : 1 seh : 0 sei : 1 sen : 0 ser : 3 ses : 0 set : 0 sev : 0 sez : 0 sleep : 0 spm : 2 st : 74 std : 8 sts : 1 sub : 6 subi : 3 swap : 0 tst : 0 wdr : 0 Instructions used: 70 out of 113 (61.9%) "ATmega32U4" memory use summary [bytes]: Segment Begin End Code Data Used Size Use% --------------------------------------------------------------- [.cseg] 0x000000 0x007fe2 1868 11624 13492 32768 41.2% [.dseg] 0x000100 0x0001d3 0 211 211 2560 8.2% [.eseg] 0x000000 0x0000b0 0 176 176 1024 17.2% Assembly complete, 0 errors, 8 warnings