-
Notifications
You must be signed in to change notification settings - Fork 2
/
Glossary_Sorted.txt
300 lines (300 loc) · 19.7 KB
/
Glossary_Sorted.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
;C d1 n1 -- n2 n3 floored signed div'n
;C ! x a-addr -- store cell in memory
;Z !CF adrs cfa -- set code action of a word
;Z !COLON -- change code field to DOCOLON
;Z !DEST dest adrs -- change a branch dest'n
;C # ud1 -- ud2 convert 1 digit of output
;C #> ud1 -- c-addr u end conv., get string
;C #S ud1 -- ud2 convert remaining digits
;Z #init -- n #bytes of user area init data
;C ' -- xt find word in dictionary
;Z 'source -- a-addr two cells: len, adrs
;C ( -- skip input until )
;Z (+loop) -- sys1 sys2
;Z (+loop) R: sys1 sys2 --
;Z (+loop) n -- run-time code for +LOOP
;Z (DOES>) -- run-time action of DOES>
;Z (IS") -- c-addr u run-time code for S"
;Z (S") -- c-addr u run-time code for S"
;Z (do) R: -- sys1 sys2
;Z (do) n1|u1 n2|u2 -- run-time code for DO
;Z (loop) -- sys1 sys2
;Z (loop) R: sys1 sys2 -- run-time code for LOOP
;C * n1 n2 -- n3 signed multiply
;C */ n1 n2 n3 -- n4 n1*n2/n3
;C */MOD n1 n2 n3 -- n4 n5 n1*n2/n3, rem"
;C + n1/u1 n2/u2 -- n3/u3 add n1+n2
;C +! n/u a-addr -- add cell to memory
;C +LOOP adrs -- L: 0 a1 a2 .. aN --
;C , x -- append cell to dict
;Z ,BRANCH xt -- append a branch instruction
;Z ,CALL adrs -- append a subroutine CALL
;Z ,CF adrs -- append a code field
;Z ,DEST dest -- append a branch address
;Z ,EXIT -- append hi-level EXIT action
;Z ,JMP adrs -- append an absolute 16-bit JMP
;Z ,NONE -- append a null destination (Flashable)
;C - n1/u1 n2/u2 -- n3/u3 subtract n1-n2
;Z -1 -- n constant -1
;C . n -- display n signed
;C ." -- compile string to print
;X .S -- print stack contents
;X .VER -- print version string.
;Z .org 1080h - VECAREA: user interrupt vectors, 15 vectors of 2 cells each
;Z .org FFE0h - intvecs: JSR VECAREA+index
;C / n1 n2 -- n3 signed divide
;C /MOD n1 n2 -- n3 n4 signed divide/rem'dr
;X /STRING a u n -- a+n u-n trim string
;Z 0 -- n constant 0
;C 0< n -- flag true if TOS negative
;C 0= n/u -- flag return true if TOS=0
;Z 1 -- n constant 1
;C 1+ n1/u1 -- n2/u2 add 1 to TOS
;C 1- n1/u1 -- n2/u2 subtract 1 from TOS
;Z 16KB flash ROM, 0.5KB RAM
;Z 2 -- n constant 2
;C 2! x1 x2 a-addr -- store 2 cells
;C 2* x1 -- x2 arithmetic left shift
;C 2/ x1 -- x2 arithmetic right shift
;C 2@ a-addr -- x1 x2 fetch 2 cells
;C 2CONSTANT -- define a Forth double constant (uho)
;C 2DROP x1 x2 -- drop 2 cells
;C 2DUP x1 x2 -- x1 x2 x1 x2 dup top 2 cells
;C 2OVER x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2
;C 2SWAP x1 x2 x3 x4 -- x3 x4 x1 x2 per diagram
;C : -- begin a colon definition
;C ;
;Z ;PN -- send delimiter ; followed by parameter ;mk
;C < n1 n2 -- flag test n1<n2, signed
;C <# -- begin numeric conversion
;X <> x1 x2 -- flag test not eq (not ANSI)
;Z <BUILDS -- define a word with t.b.d. action & no data
;C = x1 x2 -- flag test x1=x2
;C > n1 n2 -- flag test n1>n2, signed
;Z >< x1 -- x2 swap bytes (not ANSI)
;C >BODY xt -- a-addr adrs of CREATE data
;C >IN -- a-addr holds offset into TIB
;Z >L x -- L: -- x
;C >NUMBER ud adr u -- ud' adr' u' convert string to number
;C >R x -- R: -- x
;Z >counted src n dst -- copy to counted str
;Z >digit n -- c convert to 0..9A..Z
;Z ?ABORT f c-addr u -- abort & print msg
;Z ?DNEGATE d1 n -- d2 negate d1 if n negative
;C ?DUP x -- 0 | x x DUP if nonzero
;Z ?EMIT c -- send character if not null
;Z ?NEGATE n1 n2 -- n3 negate n1 if n2 negative
;Z ?NUMBER c-addr -- c-addr 0 if convert error
;Z ?NUMBER c-addr -- n -1 string->number
;Z ?SIGN adr n -- adr' n' f get optional sign
;Z ?SIGN advance adr/n if sign; return NZ if negative
;Z ?branch x -- branch if TOS zero
;C @ a-addr -- x fetch cell from memory
;C ABORT i*x -- R: j*x --
;C ABORT" i*x 0 -- i*x | R: j*x -- j*x
;C ABORT" i*x x1 -- | R: j*x -- x1<>0
;C ABS n1 -- +n2 absolute value
;C ACCEPT c-addr +n -- +n' get line from term'l
;Z ADR>IN c-addr' -- set >IN to offset to given adr
;X AGAIN adrs -- uncond'l backward branch
;C ALIGN -- align HERE
;C ALIGNED addr -- a-addr align given addr
;C ALLOT n -- allocate n bytes in dict
;C AND x1 x2 -- x3 logical AND
;U AT-XY x y -- set cursor position in terminal ;mk
;C BASE -- a-addr holds conversion radix
;C BEGIN -- adrs target for bwd. branch
;U BELL -- send $07 to Terminal
;C BL -- char an ASCII space
;C C! char c-addr -- store char in memory
;C C, char -- append char to dict
;C C@ c-addr -- char fetch char from memory
;C CAPITALIZE c-addr -- c-addr capitalize string
;Z CAPS -- a-addr CAPS=true --> case sensitive ;mk
;Z CCLRB c c-addr -- clear bits in memory byte
;Z CELL -- n size of one cell
;C CELL+ a-addr1 -- a-addr2 add cell size
;C CELLS n1 -- n2 cells->adrs units
;C CHAR -- char parse ASCII character
;C CHAR+ c-addr1 -- c-addr2 add char size
;C CHARS n1 -- n2 chars->adrs units
;Z CLRB u a-addr -- clear bits in memory cell
;X CMOVE c-addr1 c-addr2 u -- move from bottom
;X CMOVE> c-addr1 c-addr2 u -- move from top
;Z COLD -- cold start Forth system
;Z COMPILE -- append inline execution token
;X COMPILE, xt -- append execution token
;C CONSTANT -- define a Forth constant
;C COUNT c-addr1 -- c-addr2 u counted->adr/len
;C CR -- output newline
;C CREATE -- create an empty definition
;Z CSETB c c-addr -- set bits in memory byte
;U CTOGB mask addr -- flip bit from mask in addr (byte) ;mk
;Z CTSTB c c-addr -- c2 test bits in memory byte
;Z D->I c-addr1 c-addr2 u -- move Data->Code
;X DABS d1 -- +d2 absolute value dbl.prec.
;C DECIMAL -- set number base to decimal
;C DEPTH -- +n number of items on stack
;Z DIGIT? c -- n -1 if c is a valid digit
;Z DIGIT? c -- x 0
;X DNEGATE d1 -- d2 negate double precision
;C DO -- adrs L: -- 0
;C DOES> -- change action of latest def'n
;C DROP x -- drop top of stack
;X DUMP adr n --
;C DUP x -- x x duplicate top of stack
;C ELSE adrs1 -- adrs2 branch for IF..ELSE
;C EMIT c -- output character to console
;Z ENDLOOP adrs xt -- L: 0 a1 a2 .. aN --
;C ENVIRONMENT? c-addr u -- false system query
;Z ESC[ -- start esc-sequence
;C EVALUATE i*x c-addr u -- j*x interprt string
;C EXECUTE i*x xt -- j*x execute Forth word at 'xt'
;C EXIT -- exit a colon definition
;C FILL c-addr u char -- fill memory with char
;C FIND c-addr -- c-addr 0 if not found
;C FIND c-addr -- xt 1
;C FIND c-addr -- xt -1 if "normal"
;Z FLALIGNED a -- a' align IDP to flash boundary
;Z FLERASE a-addr n --
;C FM/MOD d1 n1 -- n2 n3 floored signed div'n
;U GREEN -- mask port green LED mask and port out address
;Z HEADER -- create a Forth word header
;C HERE -- addr returns dictionary ptr
;X HEX -- set number base to hex
;Z HIDE -- "hide" latest definition
;C HOLD char -- add char to output string
;C I -- n get the innermost loop index
;C I R: sys1 sys2 -- sys1 sys2
;Z I! x a-addr -- store cell in Instruction memory
;C I, x -- append cell to Code dict
;Z I->D c-addr1 c-addr2 u -- move Code->Data
;Z I@ a-addr -- x fetch cell from Instruction memory
;C IALLOT n -- allocate n bytes in Code dict
;Z IC! x a-addr -- store char in Instruction memory
;C IC, char -- append char to Code dict
;Z IC@ a-addr -- x fetch char from Instruction memory
;Z ICOUNT c-addr1 -- c-addr2 u counted->adr/len
;Z IDP -- a-addr ROM dictionary pointer
;C IF -- adrs conditional forward branch
;C IHERE -- addr returns Code dictionary ptr
;Z IMMED? nfa -- f fetch immediate flag
;C IMMEDIATE -- make last def'n immediate
;Z INSTALL n -- | "word" Installs the body of the "word" as interrupt vector #n.
;Z INTERPRET i*x c-addr u -- j*x interpret given buffer
;Z INTERRUPT: -- begin a high-level interrupt word
;C INVERT x1 -- x2 bitwise inversion
;Z IS" -- compile in-line string
;Z ITYPE c-addr +n -- type line to term'l
;Z IWORD c -- c-addr WORD to Code space
;C J -- n get the second loop index
;C J R: 4*sys -- 4*sys
;C KEY -- c get character from keyboard
;X KEY? -- f return true if char waiting
;Z L> -- x L: x --
;C LEAVE -- L: -- adrs
;C LITERAL x -- append numeric literal
;C LOOP adrs -- L: 0 a1 a2 .. aN --
;Z LP -- a-addr Leave-stack pointer
;C LSHIFT x1 u -- x2 logical L shift u places
;C M* n1 n2 -- d signed 16*16->32 multiply
;X M+ d n -- d add single to double
;X MARKER -- create word to restore dictionary
;C MAX n1 n2 -- n3 signed maximum
;Z MEMORY MAP of the MSP430G2553
;C MIN n1 n2 -- n3 signed minimum
;C MOD n1 n2 -- n3 signed remainder
;C MOVE addr1 addr2 u -- smart move
;Z N= c-addr1 c-addr2 u -- n name compare
;Z N= n<0: s1<s2, n=0: s1=s2, n>0: s1>s2
;C NEGATE x1 -- x2 two's complement
;Z NEWEST -- a-addr temporary LATEST storage
;Z NFA>CFA nfa -- cfa name adr -> code field
;Z NFA>LFA nfa -- lfa name adr -> link field
;X NIP x1 x2 -- x2 per stack diagram
;C OR x1 x2 -- x3 logical OR
;C OVER x1 x2 -- x1 x2 x1 per stack diagram
;U P1IN -- adr P1 input register address.
;U P1OUT -- adr P1 output register address.
;X PAD -- a-addr user PAD buffer
;U PAGE -- send "page" command to terminal to clear screen. ;mk
;X PARSE char -- c-addr n word delim'd by char
;Z PN -- send parameter of esc-sequence
;C POSTPONE -- postpone compile action of word
;C QUIT -- R: i*x --
;C R> -- x R: x --
;C R@ -- x R: x -- x
;C RECURSE -- recurse current definition
;U RED -- mask port red LED mask and port out address
;C REPEAT adrs2 adrs1 -- resolve WHILE loop
;Z REVEAL -- "reveal" latest definition
;C ROT x1 x2 x3 -- x2 x3 x1 per stack diagram
;Z RP! a-addr -- set return stack pointer
;Z RP@ -- a-addr get return stack pointer
;C RSHIFT x1 u -- x2 logical R shift u places
;C S" -- compile in-line string
;U S2 -- mask port second button mask and port address : input regster.
;U S2? -- f Test button S2, true if pressed.
;Z S= c-addr1 c-addr2 u -- n string compare
;Z S= n<0: s1<s2, n=0: s1=s2, n>0: s1>s2
;C S>D n -- d single -> double prec.
;Z SCAN c-addr u c -- c-addr' u' find matching char
;Z SETB u a-addr -- set bits in memory cell
;C SIGN n -- add minus sign if n<0
;Z SKIP c-addr u c -- c-addr' u' skip matching chars
;C SM/REM d1 n1 -- n2 n3 symmetric signed div
;C SOURCE -- adr n current input buffer
;Z SP! a-addr -- set data stack pointer
;Z SP@ -- a-addr get data stack pointer
;C SPACE -- output a space
;C SPACES n -- output n spaces
;C STATE -- a-addr holds compiler state
;C SWAP x1 x2 -- x2 x1 swap top two items
;C THEN adrs -- resolve forward branch
;Z TSTB u a-addr -- u2 test bits in memory cell
;X TUCK x1 x2 -- x2 x1 x2 per stack diagram
;C TYPE c-addr +n -- type line to term'l
;C U. u -- display u unsigned
;X U.R u n -- display u unsigned in n width
;C U< u1 u2 -- flag test u1<u2, unsigned
;X U> u1 u2 -- flag u1>u2 unsgd (not ANSI)
;Z UD* ud1 d2 -- ud3 32*16->32 multiply
;Z UD/MOD ud1 u2 -- u3 ud4 32/16->32 divide
;C UM* u1 u2 -- ud unsigned 16x16->32 mult.
;C UM/MOD ud u1 -- u2 u3 unsigned 32/16->16
;C UNLOOP -- drop loop parms
;C UNLOOP R: sys1 sys2 --
;C UNTIL adrs -- conditional backward branch
;C UPC char -- char capitalize character
;Z USER n -- define user variable 'n'
;C VARIABLE -- define a Forth VARIABLE
;C WHILE adrs1 -- adrs2 adrs1
;X WITHIN n1|u1 n2|u2 n3|u3 -- f n2<=n1<n3?
;C WORD char -- c-addr word delim'd by char
;X WORDS -- list all words in dict.
;X WORDS -- list all words in dict. Stop and go feature.
;Z XON/OFF -- a-addr XON and XOFF characters
;C XOR x1 x2 -- x3 logical XOR
;C [ -- enter interpretive state
;C ['] -- find word & compile as literal
;C [CHAR] -- compile character literal
;U \ -- backslash
;C ] -- enter compiling state
;Z and then does COLD to reset the User Variables.
;Z branch -- branch always
;Z copies the User Area and subsequent RAM variables there.
;Z dp -- a-addr holds dictionary ptr
;Z hp -- a-addr HOLD pointer
;Z l0 -- a-addr bottom of Leave stack
;Z latest -- a-addr last word in dict.
;Z lit -- x fetch inline literal to stack
;Z main - reset jumps to main.
;Z r0 -- a-addr end of return stack
;Z s0 -- a-addr end of parameter stack
;Z the User Area and subsequent RAM.
;X tib -- a-addr Terminal Input Buffer
;Z tibsize -- n size of TIB
;Z u0 -- a-addr current user area adrs
;Z uinit -- addr initial values for user area
;Z umax u1 u2 -- u unsigned maximum
;Z umin u1 u2 -- u unsigned minimum