File:
[gforth] /
gforth /
Attic /
gforth.ds
Revision
1.19:
download - view:
text,
annotated -
select for diffs
Mon Oct 16 18:33:08 1995 UTC (28 years, 6 months ago) by
anton
Branches:
MAIN
CVS tags:
HEAD
added answords.fs and strsignal.c
added checking of documenetation of ANS Forth words
Fixed many documentation errors and added some documentation
signal handling now uses strsignal and can handle signals not present on all machines
1: \input texinfo @c -*-texinfo-*-
2: @comment The source is gforth.ds, from which gforth.texi is generated
3: @comment %**start of header (This is for running Texinfo on a region.)
4: @setfilename gforth.info
5: @settitle Gforth Manual
6: @comment @setchapternewpage odd
7: @comment %**end of header (This is for running Texinfo on a region.)
8:
9: @ifinfo
10: This file documents Gforth 0.1
11:
12: Copyright @copyright{} 1994 Gforth Development Group
13:
14: Permission is granted to make and distribute verbatim copies of
15: this manual provided the copyright notice and this permission notice
16: are preserved on all copies.
17:
18: @ignore
19: Permission is granted to process this file through TeX and print the
20: results, provided the printed document carries a copying permission
21: notice identical to this one except for the removal of this paragraph
22: (this paragraph not being relevant to the printed manual).
23:
24: @end ignore
25: Permission is granted to copy and distribute modified versions of this
26: manual under the conditions for verbatim copying, provided also that the
27: sections entitled "Distribution" and "General Public License" are
28: included exactly as in the original, and provided that the entire
29: resulting derived work is distributed under the terms of a permission
30: notice identical to this one.
31:
32: Permission is granted to copy and distribute translations of this manual
33: into another language, under the above conditions for modified versions,
34: except that the sections entitled "Distribution" and "General Public
35: License" may be included in a translation approved by the author instead
36: of in the original English.
37: @end ifinfo
38:
39: @titlepage
40: @sp 10
41: @center @titlefont{Gforth Manual}
42: @sp 2
43: @center for version 0.1
44: @sp 2
45: @center Anton Ertl
46: @sp 3
47: @center This manual is under construction
48:
49: @comment The following two commands start the copyright page.
50: @page
51: @vskip 0pt plus 1filll
52: Copyright @copyright{} 1994 Gforth Development Group
53:
54: @comment !! Published by ... or You can get a copy of this manual ...
55:
56: Permission is granted to make and distribute verbatim copies of
57: this manual provided the copyright notice and this permission notice
58: are preserved on all copies.
59:
60: Permission is granted to copy and distribute modified versions of this
61: manual under the conditions for verbatim copying, provided also that the
62: sections entitled "Distribution" and "General Public License" are
63: included exactly as in the original, and provided that the entire
64: resulting derived work is distributed under the terms of a permission
65: notice identical to this one.
66:
67: Permission is granted to copy and distribute translations of this manual
68: into another language, under the above conditions for modified versions,
69: except that the sections entitled "Distribution" and "General Public
70: License" may be included in a translation approved by the author instead
71: of in the original English.
72: @end titlepage
73:
74:
75: @node Top, License, (dir), (dir)
76: @ifinfo
77: Gforth is a free implementation of ANS Forth available on many
78: personal machines. This manual corresponds to version 0.0.
79: @end ifinfo
80:
81: @menu
82: * License::
83: * Goals:: About the Gforth Project
84: * Other Books:: Things you might want to read
85: * Invocation:: Starting Gforth
86: * Words:: Forth words available in Gforth
87: * ANS conformance:: Implementation-defined options etc.
88: * Model:: The abstract machine of Gforth
89: * Emacs and Gforth:: The Gforth Mode
90: * Internals:: Implementation details
91: * Bugs:: How to report them
92: * Pedigree:: Ancestors of Gforth
93: * Word Index:: An item for each Forth word
94: * Node Index:: An item for each node
95: @end menu
96:
97: @node License, Goals, Top, Top
98: @unnumbered License
99: !! Insert GPL here
100:
101: @iftex
102: @unnumbered Preface
103: This manual documents Gforth. The reader is expected to know
104: Forth. This manual is primarily a reference manual. @xref{Other Books}
105: for introductory material.
106: @end iftex
107:
108: @node Goals, Other Books, License, Top
109: @comment node-name, next, previous, up
110: @chapter Goals of Gforth
111: @cindex Goals
112: The goal of the Gforth Project is to develop a standard model for
113: ANSI Forth. This can be split into several subgoals:
114:
115: @itemize @bullet
116: @item
117: Gforth should conform to the ANSI Forth standard.
118: @item
119: It should be a model, i.e. it should define all the
120: implementation-dependent things.
121: @item
122: It should become standard, i.e. widely accepted and used. This goal
123: is the most difficult one.
124: @end itemize
125:
126: To achieve these goals Gforth should be
127: @itemize @bullet
128: @item
129: Similar to previous models (fig-Forth, F83)
130: @item
131: Powerful. It should provide for all the things that are considered
132: necessary today and even some that are not yet considered necessary.
133: @item
134: Efficient. It should not get the reputation of being exceptionally
135: slow.
136: @item
137: Free.
138: @item
139: Available on many machines/easy to port.
140: @end itemize
141:
142: Have we achieved these goals? Gforth conforms to the ANS Forth
143: standard. It may be considered a model, but we have not yet documented
144: which parts of the model are stable and which parts we are likely to
145: change. It certainly has not yet become a de facto standard. It has some
146: similarities and some differences to previous models. It has some
147: powerful features, but not yet everything that we envisioned. We
148: certainly have achieved our execution speed goals (@pxref{Performance}).
149: It is free and available on many machines.
150:
151: @node Other Books, Invocation, Goals, Top
152: @chapter Other books on ANS Forth
153:
154: As the standard is relatively new, there are not many books out yet. It
155: is not recommended to learn Forth by using Gforth and a book that is
156: not written for ANS Forth, as you will not know your mistakes from the
157: deviations of the book.
158:
159: There is, of course, the standard, the definite reference if you want to
160: write ANS Forth programs. It is available in printed form from the
161: National Standards Institute Sales Department (Tel.: USA (212) 642-4900;
162: Fax.: USA (212) 302-1286) as document @cite{X3.215-1994} for about $200. You
163: can also get it from Global Engineering Documents (Tel.: USA (800)
164: 854-7179; Fax.: (303) 843-9880) for about $300.
165:
166: @cite{dpANS6}, the last draft of the standard, which was then submitted to ANSI
167: for publication is available electronically and for free in some MS Word
168: format, and it has been converted to HTML. Some pointers to these
169: versions can be found through
170: http://www.complang.tuwien.ac.at/projects/forth.html.
171:
172: @cite{Forth: The new model} by Jack Woehr (!! Publisher) is an
173: introductory book based on a draft version of the standard. It does not
174: cover the whole standard. It also contains interesting background
175: information (Jack Woehr was in the ANS Forth Technical Committe). It is
176: not appropriate for complete newbies, but programmers experienced in
177: other languages should find it ok.
178:
179: @node Invocation, Words, Other Books, Top
180: @chapter Invocation
181:
182: You will usually just say @code{gforth}. In many other cases the default
183: Gforth image will be invoked like this:
184:
185: @example
186: gforth [files] [-e forth-code]
187: @end example
188:
189: executing the contents of the files and the Forth code in the order they
190: are given.
191:
192: In general, the command line looks like this:
193:
194: @example
195: gforth [initialization options] [image-specific options]
196: @end example
197:
198: The initialization options must come before the rest of the command
199: line. They are:
200:
201: @table @code
202: @item --image-file @var{file}
203: Loads the Forth image @var{file} instead of the default
204: @file{gforth.fi}.
205:
206: @item --path @var{path}
207: Uses @var{path} for searching the image file and Forth source code
208: files instead of the default in the environment variable
209: @code{GFORTHPATH} or the path specified at installation time (typically
210: @file{/usr/local/lib/gforth:.}). A path is given as a @code{:}-separated
211: list.
212:
213: @item --dictionary-size @var{size}
214: @item -m @var{size}
215: Allocate @var{size} space for the Forth dictionary space instead of
216: using the default specified in the image (typically 256K). The
217: @var{size} specification consists of an integer and a unit (e.g.,
218: @code{4M}). The unit can be one of @code{b} (bytes), @code{e} (element
219: size, in this case Cells), @code{k} (kilobytes), and @code{M}
220: (Megabytes). If no unit is specified, @code{e} is used.
221:
222: @item --data-stack-size @var{size}
223: @item -d @var{size}
224: Allocate @var{size} space for the data stack instead of using the
225: default specified in the image (typically 16K).
226:
227: @item --return-stack-size @var{size}
228: @item -r @var{size}
229: Allocate @var{size} space for the return stack instead of using the
230: default specified in the image (typically 16K).
231:
232: @item --fp-stack-size @var{size}
233: @item -f @var{size}
234: Allocate @var{size} space for the floating point stack instead of
235: using the default specified in the image (typically 16K). In this case
236: the unit specifier @code{e} refers to floating point numbers.
237:
238: @item --locals-stack-size @var{size}
239: @item -l @var{size}
240: Allocate @var{size} space for the locals stack instead of using the
241: default specified in the image (typically 16K).
242:
243: @end table
244:
245: As explained above, the image-specific command-line arguments for the
246: default image @file{gforth.fi} consist of a sequence of filenames and
247: @code{-e @var{forth-code}} options that are interpreted in the seqence
248: in which they are given. The @code{-e @var{forth-code}} or
249: @code{--evaluate @var{forth-code}} option evaluates the forth
250: code. This option takes only one argument; if you want to evaluate more
251: Forth words, you have to quote them or use several @code{-e}s. To exit
252: after processing the command line (instead of entering interactive mode)
253: append @code{-e bye} to the command line.
254:
255: Not yet implemented:
256: On startup the system first executes the system initialization file
257: (unless the option @code{--no-init-file} is given; note that the system
258: resulting from using this option may not be ANS Forth conformant). Then
259: the user initialization file @file{.gforth.fs} is executed, unless the
260: option @code{--no-rc} is given; this file is first searched in @file{.},
261: then in @file{~}, then in the normal path (see above).
262:
263: @node Words, ANS conformance, Invocation, Top
264: @chapter Forth Words
265:
266: @menu
267: * Notation::
268: * Arithmetic::
269: * Stack Manipulation::
270: * Memory access::
271: * Control Structures::
272: * Locals::
273: * Defining Words::
274: * Wordlists::
275: * Files::
276: * Blocks::
277: * Other I/O::
278: * Programming Tools::
279: * Assembler and Code words::
280: * Threading Words::
281: @end menu
282:
283: @node Notation, Arithmetic, Words, Words
284: @section Notation
285:
286: The Forth words are described in this section in the glossary notation
287: that has become a de-facto standard for Forth texts, i.e.
288:
289: @format
290: @var{word} @var{Stack effect} @var{wordset} @var{pronunciation}
291: @end format
292: @var{Description}
293:
294: @table @var
295: @item word
296: The name of the word. BTW, Gforth is case insensitive, so you can
297: type the words in in lower case (However, @pxref{core-idef}).
298:
299: @item Stack effect
300: The stack effect is written in the notation @code{@var{before} --
301: @var{after}}, where @var{before} and @var{after} describe the top of
302: stack entries before and after the execution of the word. The rest of
303: the stack is not touched by the word. The top of stack is rightmost,
304: i.e., a stack sequence is written as it is typed in. Note that Gforth
305: uses a separate floating point stack, but a unified stack
306: notation. Also, return stack effects are not shown in @var{stack
307: effect}, but in @var{Description}. The name of a stack item describes
308: the type and/or the function of the item. See below for a discussion of
309: the types.
310:
311: All words have two stack effects: A compile-time stack effect and a
312: run-time stack effect. The compile-time stack-effect of most words is
313: @var{ -- }. If the compile-time stack-effect of a word deviates from
314: this standard behaviour, or the word does other unusual things at
315: compile time, both stack effects are shown; otherwise only the run-time
316: stack effect is shown.
317:
318: @item pronunciation
319: How the word is pronounced
320:
321: @item wordset
322: The ANS Forth standard is divided into several wordsets. A standard
323: system need not support all of them. So, the fewer wordsets your program
324: uses the more portable it will be in theory. However, we suspect that
325: most ANS Forth systems on personal machines will feature all
326: wordsets. Words that are not defined in the ANS standard have
327: @code{gforth} or @code{gforth-internal} as wordset. @code{gforth}
328: describes words that will work in future releases of Gforth;
329: @code{gforth-internal} words are more volatile. Environmental query
330: strings are also displayed like words; you can recognize them by the
331: @code{environment} in the wordset field.
332:
333: @item Description
334: A description of the behaviour of the word.
335: @end table
336:
337: The type of a stack item is specified by the character(s) the name
338: starts with:
339:
340: @table @code
341: @item f
342: Bool, i.e. @code{false} or @code{true}.
343: @item c
344: Char
345: @item w
346: Cell, can contain an integer or an address
347: @item n
348: signed integer
349: @item u
350: unsigned integer
351: @item d
352: double sized signed integer
353: @item ud
354: double sized unsigned integer
355: @item r
356: Float
357: @item a_
358: Cell-aligned address
359: @item c_
360: Char-aligned address (note that a Char is two bytes in Windows NT)
361: @item f_
362: Float-aligned address
363: @item df_
364: Address aligned for IEEE double precision float
365: @item sf_
366: Address aligned for IEEE single precision float
367: @item xt
368: Execution token, same size as Cell
369: @item wid
370: Wordlist ID, same size as Cell
371: @item f83name
372: Pointer to a name structure
373: @end table
374:
375: @node Arithmetic, Stack Manipulation, Notation, Words
376: @section Arithmetic
377: Forth arithmetic is not checked, i.e., you will not hear about integer
378: overflow on addition or multiplication, you may hear about division by
379: zero if you are lucky. The operator is written after the operands, but
380: the operands are still in the original order. I.e., the infix @code{2-1}
381: corresponds to @code{2 1 -}. Forth offers a variety of division
382: operators. If you perform division with potentially negative operands,
383: you do not want to use @code{/} or @code{/mod} with its undefined
384: behaviour, but rather @code{fm/mod} or @code{sm/mod} (probably the
385: former, @pxref{Mixed precision}).
386:
387: @menu
388: * Single precision::
389: * Bitwise operations::
390: * Mixed precision:: operations with single and double-cell integers
391: * Double precision:: Double-cell integer arithmetic
392: * Floating Point::
393: @end menu
394:
395: @node Single precision, Bitwise operations, Arithmetic, Arithmetic
396: @subsection Single precision
397: doc-+
398: doc--
399: doc-*
400: doc-/
401: doc-mod
402: doc-/mod
403: doc-negate
404: doc-abs
405: doc-min
406: doc-max
407:
408: @node Bitwise operations, Mixed precision, Single precision, Arithmetic
409: @subsection Bitwise operations
410: doc-and
411: doc-or
412: doc-xor
413: doc-invert
414: doc-2*
415: doc-2/
416:
417: @node Mixed precision, Double precision, Bitwise operations, Arithmetic
418: @subsection Mixed precision
419: doc-m+
420: doc-*/
421: doc-*/mod
422: doc-m*
423: doc-um*
424: doc-m*/
425: doc-um/mod
426: doc-fm/mod
427: doc-sm/rem
428:
429: @node Double precision, Floating Point, Mixed precision, Arithmetic
430: @subsection Double precision
431:
432: The outer (aka text) interpreter converts numbers containing a dot into
433: a double precision number. Note that only numbers with the dot as last
434: character are standard-conforming.
435:
436: doc-d+
437: doc-d-
438: doc-dnegate
439: doc-dabs
440: doc-dmin
441: doc-dmax
442:
443: @node Floating Point, , Double precision, Arithmetic
444: @subsection Floating Point
445:
446: The format of floating point numbers recognized by the outer (aka text)
447: interpreter is: a signed decimal number, possibly containing a decimal
448: point (@code{.}), followed by @code{E} or @code{e}, optionally followed
449: by a signed integer (the exponent). E.g., @code{1e} ist the same as
450: @code{+1.0e+1}. Note that a number without @code{e}
451: is not interpreted as floating-point number, but as double (if the
452: number contains a @code{.}) or single precision integer. Also,
453: conversions between string and floating point numbers always use base
454: 10, irrespective of the value of @code{BASE}. If @code{BASE} contains a
455: value greater then 14, the @code{E} may be interpreted as digit and the
456: number will be interpreted as integer, unless it has a signed exponent
457: (both @code{+} and @code{-} are allowed as signs).
458:
459: Angles in floating point operations are given in radians (a full circle
460: has 2 pi radians). Note, that Gforth has a separate floating point
461: stack, but we use the unified notation.
462:
463: Floating point numbers have a number of unpleasant surprises for the
464: unwary (e.g., floating point addition is not associative) and even a few
465: for the wary. You should not use them unless you know what you are doing
466: or you don't care that the results you get are totally bogus. If you
467: want to learn about the problems of floating point numbers (and how to
468: avoid them), you might start with @cite{David Goldberg, What Every
469: Computer Scientist Should Know About Floating-Point Arithmetic, ACM
470: Computing Surveys 23(1):5@minus{}48, March 1991}.
471:
472: doc-f+
473: doc-f-
474: doc-f*
475: doc-f/
476: doc-fnegate
477: doc-fabs
478: doc-fmax
479: doc-fmin
480: doc-floor
481: doc-fround
482: doc-f**
483: doc-fsqrt
484: doc-fexp
485: doc-fexpm1
486: doc-fln
487: doc-flnp1
488: doc-flog
489: doc-falog
490: doc-fsin
491: doc-fcos
492: doc-fsincos
493: doc-ftan
494: doc-fasin
495: doc-facos
496: doc-fatan
497: doc-fatan2
498: doc-fsinh
499: doc-fcosh
500: doc-ftanh
501: doc-fasinh
502: doc-facosh
503: doc-fatanh
504:
505: @node Stack Manipulation, Memory access, Arithmetic, Words
506: @section Stack Manipulation
507:
508: Gforth has a data stack (aka parameter stack) for characters, cells,
509: addresses, and double cells, a floating point stack for floating point
510: numbers, a return stack for storing the return addresses of colon
511: definitions and other data, and a locals stack for storing local
512: variables. Note that while every sane Forth has a separate floating
513: point stack, this is not strictly required; an ANS Forth system could
514: theoretically keep floating point numbers on the data stack. As an
515: additional difficulty, you don't know how many cells a floating point
516: number takes. It is reportedly possible to write words in a way that
517: they work also for a unified stack model, but we do not recommend trying
518: it. Instead, just say that your program has an environmental dependency
519: on a separate FP stack.
520:
521: Also, a Forth system is allowed to keep the local variables on the
522: return stack. This is reasonable, as local variables usually eliminate
523: the need to use the return stack explicitly. So, if you want to produce
524: a standard complying program and if you are using local variables in a
525: word, forget about return stack manipulations in that word (see the
526: standard document for the exact rules).
527:
528: @menu
529: * Data stack::
530: * Floating point stack::
531: * Return stack::
532: * Locals stack::
533: * Stack pointer manipulation::
534: @end menu
535:
536: @node Data stack, Floating point stack, Stack Manipulation, Stack Manipulation
537: @subsection Data stack
538: doc-drop
539: doc-nip
540: doc-dup
541: doc-over
542: doc-tuck
543: doc-swap
544: doc-rot
545: doc--rot
546: doc-?dup
547: doc-pick
548: doc-roll
549: doc-2drop
550: doc-2nip
551: doc-2dup
552: doc-2over
553: doc-2tuck
554: doc-2swap
555: doc-2rot
556:
557: @node Floating point stack, Return stack, Data stack, Stack Manipulation
558: @subsection Floating point stack
559: doc-fdrop
560: doc-fnip
561: doc-fdup
562: doc-fover
563: doc-ftuck
564: doc-fswap
565: doc-frot
566:
567: @node Return stack, Locals stack, Floating point stack, Stack Manipulation
568: @subsection Return stack
569: doc->r
570: doc-r>
571: doc-r@
572: doc-rdrop
573: doc-2>r
574: doc-2r>
575: doc-2r@
576: doc-2rdrop
577:
578: @node Locals stack, Stack pointer manipulation, Return stack, Stack Manipulation
579: @subsection Locals stack
580:
581: @node Stack pointer manipulation, , Locals stack, Stack Manipulation
582: @subsection Stack pointer manipulation
583: doc-sp@
584: doc-sp!
585: doc-fp@
586: doc-fp!
587: doc-rp@
588: doc-rp!
589: doc-lp@
590: doc-lp!
591:
592: @node Memory access, Control Structures, Stack Manipulation, Words
593: @section Memory access
594:
595: @menu
596: * Stack-Memory transfers::
597: * Address arithmetic::
598: * Memory block access::
599: @end menu
600:
601: @node Stack-Memory transfers, Address arithmetic, Memory access, Memory access
602: @subsection Stack-Memory transfers
603:
604: doc-@
605: doc-!
606: doc-+!
607: doc-c@
608: doc-c!
609: doc-2@
610: doc-2!
611: doc-f@
612: doc-f!
613: doc-sf@
614: doc-sf!
615: doc-df@
616: doc-df!
617:
618: @node Address arithmetic, Memory block access, Stack-Memory transfers, Memory access
619: @subsection Address arithmetic
620:
621: ANS Forth does not specify the sizes of the data types. Instead, it
622: offers a number of words for computing sizes and doing address
623: arithmetic. Basically, address arithmetic is performed in terms of
624: address units (aus); on most systems the address unit is one byte. Note
625: that a character may have more than one au, so @code{chars} is no noop
626: (on systems where it is a noop, it compiles to nothing).
627:
628: ANS Forth also defines words for aligning addresses for specific
629: addresses. Many computers require that accesses to specific data types
630: must only occur at specific addresses; e.g., that cells may only be
631: accessed at addresses divisible by 4. Even if a machine allows unaligned
632: accesses, it can usually perform aligned accesses faster.
633:
634: For the performance-conscious: alignment operations are usually only
635: necessary during the definition of a data structure, not during the
636: (more frequent) accesses to it.
637:
638: ANS Forth defines no words for character-aligning addresses. This is not
639: an oversight, but reflects the fact that addresses that are not
640: char-aligned have no use in the standard and therefore will not be
641: created.
642:
643: The standard guarantees that addresses returned by @code{CREATE}d words
644: are cell-aligned; in addition, Gforth guarantees that these addresses
645: are aligned for all purposes.
646:
647: Note that the standard defines a word @code{char}, which has nothing to
648: do with address arithmetic.
649:
650: doc-chars
651: doc-char+
652: doc-cells
653: doc-cell+
654: doc-align
655: doc-aligned
656: doc-floats
657: doc-float+
658: doc-falign
659: doc-faligned
660: doc-sfloats
661: doc-sfloat+
662: doc-sfalign
663: doc-sfaligned
664: doc-dfloats
665: doc-dfloat+
666: doc-dfalign
667: doc-dfaligned
668: doc-maxalign
669: doc-maxaligned
670: doc-cfalign
671: doc-cfaligned
672: doc-address-unit-bits
673:
674: @node Memory block access, , Address arithmetic, Memory access
675: @subsection Memory block access
676:
677: doc-move
678: doc-erase
679:
680: While the previous words work on address units, the rest works on
681: characters.
682:
683: doc-cmove
684: doc-cmove>
685: doc-fill
686: doc-blank
687:
688: @node Control Structures, Locals, Memory access, Words
689: @section Control Structures
690:
691: Control structures in Forth cannot be used in interpret state, only in
692: compile state, i.e., in a colon definition. We do not like this
693: limitation, but have not seen a satisfying way around it yet, although
694: many schemes have been proposed.
695:
696: @menu
697: * Selection::
698: * Simple Loops::
699: * Counted Loops::
700: * Arbitrary control structures::
701: * Calls and returns::
702: * Exception Handling::
703: @end menu
704:
705: @node Selection, Simple Loops, Control Structures, Control Structures
706: @subsection Selection
707:
708: @example
709: @var{flag}
710: IF
711: @var{code}
712: ENDIF
713: @end example
714: or
715: @example
716: @var{flag}
717: IF
718: @var{code1}
719: ELSE
720: @var{code2}
721: ENDIF
722: @end example
723:
724: You can use @code{THEN} instead of @code{ENDIF}. Indeed, @code{THEN} is
725: standard, and @code{ENDIF} is not, although it is quite popular. We
726: recommend using @code{ENDIF}, because it is less confusing for people
727: who also know other languages (and is not prone to reinforcing negative
728: prejudices against Forth in these people). Adding @code{ENDIF} to a
729: system that only supplies @code{THEN} is simple:
730: @example
731: : endif POSTPONE then ; immediate
732: @end example
733:
734: [According to @cite{Webster's New Encyclopedic Dictionary}, @dfn{then
735: (adv.)} has the following meanings:
736: @quotation
737: ... 2b: following next after in order ... 3d: as a necessary consequence
738: (if you were there, then you saw them).
739: @end quotation
740: Forth's @code{THEN} has the meaning 2b, whereas @code{THEN} in Pascal
741: and many other programming languages has the meaning 3d.]
742:
743: We also provide the words @code{?dup-if} and @code{?dup-0=-if}, so you
744: can avoid using @code{?dup}.
745:
746: @example
747: @var{n}
748: CASE
749: @var{n1} OF @var{code1} ENDOF
750: @var{n2} OF @var{code2} ENDOF
751: @dots{}
752: ENDCASE
753: @end example
754:
755: Executes the first @var{codei}, where the @var{ni} is equal to
756: @var{n}. A default case can be added by simply writing the code after
757: the last @code{ENDOF}. It may use @var{n}, which is on top of the stack,
758: but must not consume it.
759:
760: @node Simple Loops, Counted Loops, Selection, Control Structures
761: @subsection Simple Loops
762:
763: @example
764: BEGIN
765: @var{code1}
766: @var{flag}
767: WHILE
768: @var{code2}
769: REPEAT
770: @end example
771:
772: @var{code1} is executed and @var{flag} is computed. If it is true,
773: @var{code2} is executed and the loop is restarted; If @var{flag} is false, execution continues after the @code{REPEAT}.
774:
775: @example
776: BEGIN
777: @var{code}
778: @var{flag}
779: UNTIL
780: @end example
781:
782: @var{code} is executed. The loop is restarted if @code{flag} is false.
783:
784: @example
785: BEGIN
786: @var{code}
787: AGAIN
788: @end example
789:
790: This is an endless loop.
791:
792: @node Counted Loops, Arbitrary control structures, Simple Loops, Control Structures
793: @subsection Counted Loops
794:
795: The basic counted loop is:
796: @example
797: @var{limit} @var{start}
798: ?DO
799: @var{body}
800: LOOP
801: @end example
802:
803: This performs one iteration for every integer, starting from @var{start}
804: and up to, but excluding @var{limit}. The counter, aka index, can be
805: accessed with @code{i}. E.g., the loop
806: @example
807: 10 0 ?DO
808: i .
809: LOOP
810: @end example
811: prints
812: @example
813: 0 1 2 3 4 5 6 7 8 9
814: @end example
815: The index of the innermost loop can be accessed with @code{i}, the index
816: of the next loop with @code{j}, and the index of the third loop with
817: @code{k}.
818:
819: The loop control data are kept on the return stack, so there are some
820: restrictions on mixing return stack accesses and counted loop
821: words. E.g., if you put values on the return stack outside the loop, you
822: cannot read them inside the loop. If you put values on the return stack
823: within a loop, you have to remove them before the end of the loop and
824: before accessing the index of the loop.
825:
826: There are several variations on the counted loop:
827:
828: @code{LEAVE} leaves the innermost counted loop immediately.
829:
830: If @var{start} is greater than @var{limit}, a @code{?DO} loop is entered
831: (and @code{LOOP} iterates until they become equal by wrap-around
832: arithmetic). This behaviour is usually not what you want. Therefore,
833: Gforth offers @code{+DO} and @code{U+DO} (as replacements for
834: @code{?DO}), which do not enter the loop if @var{start} is greater than
835: @var{limit}; @code{+DO} is for signed loop parameters, @code{U+DO} for
836: unsigned loop parameters. These words can be implemented easily on
837: standard systems, so using them does not make your programs hard to
838: port; e.g.:
839: @example
840: : +DO ( compile-time: -- do-sys; run-time: n1 n2 -- )
841: POSTPONE over POSTPONE min POSTPONE ?DO ; immediate
842: @end example
843:
844: @code{LOOP} can be replaced with @code{@var{n} +LOOP}; this updates the
845: index by @var{n} instead of by 1. The loop is terminated when the border
846: between @var{limit-1} and @var{limit} is crossed. E.g.:
847:
848: @code{4 0 +DO i . 2 +LOOP} prints @code{0 2}
849:
850: @code{4 1 +DO i . 2 +LOOP} prints @code{1 3}
851:
852: The behaviour of @code{@var{n} +LOOP} is peculiar when @var{n} is negative:
853:
854: @code{-1 0 ?DO i . -1 +LOOP} prints @code{0 -1}
855:
856: @code{ 0 0 ?DO i . -1 +LOOP} prints nothing
857:
858: Therefore we recommend avoiding @code{@var{n} +LOOP} with negative
859: @var{n}. One alternative is @code{@var{u} -LOOP}, which reduces the
860: index by @var{u} each iteration. The loop is terminated when the border
861: between @var{limit+1} and @var{limit} is crossed. Gforth also provides
862: @code{-DO} and @code{U-DO} for down-counting loops. E.g.:
863:
864: @code{-2 0 -DO i . 1 -LOOP} prints @code{0 -1}
865:
866: @code{-1 0 -DO i . 1 -LOOP} prints @code{0}
867:
868: @code{ 0 0 -DO i . 1 -LOOP} prints nothing
869:
870: Another alternative is @code{@var{n} S+LOOP}, where the negative
871: case behaves symmetrical to the positive case:
872:
873: @code{-2 0 -DO i . -1 S+LOOP} prints @code{0 -1}
874:
875: The loop is terminated when the border between @var{limit@minus{}sgn(n)}
876: and @var{limit} is crossed. Unfortunately, neither @code{-LOOP} nor
877: @code{S+LOOP} are part of the ANS Forth standard, and they are not easy
878: to implement using standard words. If you want to write standard
879: programs, just avoid counting down.
880:
881: @code{?DO} can also be replaced by @code{DO}. @code{DO} always enters
882: the loop, independent of the loop parameters. Do not use @code{DO}, even
883: if you know that the loop is entered in any case. Such knowledge tends
884: to become invalid during maintenance of a program, and then the
885: @code{DO} will make trouble.
886:
887: @code{UNLOOP} is used to prepare for an abnormal loop exit, e.g., via
888: @code{EXIT}. @code{UNLOOP} removes the loop control parameters from the
889: return stack so @code{EXIT} can get to its return address.
890:
891: Another counted loop is
892: @example
893: @var{n}
894: FOR
895: @var{body}
896: NEXT
897: @end example
898: This is the preferred loop of native code compiler writers who are too
899: lazy to optimize @code{?DO} loops properly. In Gforth, this loop
900: iterates @var{n+1} times; @code{i} produces values starting with @var{n}
901: and ending with 0. Other Forth systems may behave differently, even if
902: they support @code{FOR} loops.
903:
904: @node Arbitrary control structures, Calls and returns, Counted Loops, Control Structures
905: @subsection Arbitrary control structures
906:
907: ANS Forth permits and supports using control structures in a non-nested
908: way. Information about incomplete control structures is stored on the
909: control-flow stack. This stack may be implemented on the Forth data
910: stack, and this is what we have done in Gforth.
911:
912: An @i{orig} entry represents an unresolved forward branch, a @i{dest}
913: entry represents a backward branch target. A few words are the basis for
914: building any control structure possible (except control structures that
915: need storage, like calls, coroutines, and backtracking).
916:
917: doc-if
918: doc-ahead
919: doc-then
920: doc-begin
921: doc-until
922: doc-again
923: doc-cs-pick
924: doc-cs-roll
925:
926: On many systems control-flow stack items take one word, in Gforth they
927: currently take three (this may change in the future). Therefore it is a
928: really good idea to manipulate the control flow stack with
929: @code{cs-pick} and @code{cs-roll}, not with data stack manipulation
930: words.
931:
932: Some standard control structure words are built from these words:
933:
934: doc-else
935: doc-while
936: doc-repeat
937:
938: Counted loop words constitute a separate group of words:
939:
940: doc-?do
941: doc-+do
942: doc-u+do
943: doc--do
944: doc-u-do
945: doc-do
946: doc-for
947: doc-loop
948: doc-s+loop
949: doc-+loop
950: doc--loop
951: doc-next
952: doc-leave
953: doc-?leave
954: doc-unloop
955: doc-done
956:
957: The standard does not allow using @code{cs-pick} and @code{cs-roll} on
958: @i{do-sys}. Our system allows it, but it's your job to ensure that for
959: every @code{?DO} etc. there is exactly one @code{UNLOOP} on any path
960: through the definition (@code{LOOP} etc. compile an @code{UNLOOP} on the
961: fall-through path). Also, you have to ensure that all @code{LEAVE}s are
962: resolved (by using one of the loop-ending words or @code{DONE}).
963:
964: Another group of control structure words are
965:
966: doc-case
967: doc-endcase
968: doc-of
969: doc-endof
970:
971: @i{case-sys} and @i{of-sys} cannot be processed using @code{cs-pick} and
972: @code{cs-roll}.
973:
974: @subsubsection Programming Style
975:
976: In order to ensure readability we recommend that you do not create
977: arbitrary control structures directly, but define new control structure
978: words for the control structure you want and use these words in your
979: program.
980:
981: E.g., instead of writing
982:
983: @example
984: begin
985: ...
986: if [ 1 cs-roll ]
987: ...
988: again then
989: @end example
990:
991: we recommend defining control structure words, e.g.,
992:
993: @example
994: : while ( dest -- orig dest )
995: POSTPONE if
996: 1 cs-roll ; immediate
997:
998: : repeat ( orig dest -- )
999: POSTPONE again
1000: POSTPONE then ; immediate
1001: @end example
1002:
1003: and then using these to create the control structure:
1004:
1005: @example
1006: begin
1007: ...
1008: while
1009: ...
1010: repeat
1011: @end example
1012:
1013: That's much easier to read, isn't it? Of course, @code{BEGIN} and
1014: @code{WHILE} are predefined, so in this example it would not be
1015: necessary to define them.
1016:
1017: @node Calls and returns, Exception Handling, Arbitrary control structures, Control Structures
1018: @subsection Calls and returns
1019:
1020: A definition can be called simply be writing the name of the
1021: definition. When the end of the definition is reached, it returns. An
1022: earlier return can be forced using
1023:
1024: doc-exit
1025:
1026: Don't forget to clean up the return stack and @code{UNLOOP} any
1027: outstanding @code{?DO}...@code{LOOP}s before @code{EXIT}ing. The
1028: primitive compiled by @code{EXIT} is
1029:
1030: doc-;s
1031:
1032: @node Exception Handling, , Calls and returns, Control Structures
1033: @subsection Exception Handling
1034:
1035: doc-catch
1036: doc-throw
1037:
1038: @node Locals, Defining Words, Control Structures, Words
1039: @section Locals
1040:
1041: Local variables can make Forth programming more enjoyable and Forth
1042: programs easier to read. Unfortunately, the locals of ANS Forth are
1043: laden with restrictions. Therefore, we provide not only the ANS Forth
1044: locals wordset, but also our own, more powerful locals wordset (we
1045: implemented the ANS Forth locals wordset through our locals wordset).
1046:
1047: @menu
1048: * Gforth locals::
1049: * ANS Forth locals::
1050: @end menu
1051:
1052: @node Gforth locals, ANS Forth locals, Locals, Locals
1053: @subsection Gforth locals
1054:
1055: Locals can be defined with
1056:
1057: @example
1058: @{ local1 local2 ... -- comment @}
1059: @end example
1060: or
1061: @example
1062: @{ local1 local2 ... @}
1063: @end example
1064:
1065: E.g.,
1066: @example
1067: : max @{ n1 n2 -- n3 @}
1068: n1 n2 > if
1069: n1
1070: else
1071: n2
1072: endif ;
1073: @end example
1074:
1075: The similarity of locals definitions with stack comments is intended. A
1076: locals definition often replaces the stack comment of a word. The order
1077: of the locals corresponds to the order in a stack comment and everything
1078: after the @code{--} is really a comment.
1079:
1080: This similarity has one disadvantage: It is too easy to confuse locals
1081: declarations with stack comments, causing bugs and making them hard to
1082: find. However, this problem can be avoided by appropriate coding
1083: conventions: Do not use both notations in the same program. If you do,
1084: they should be distinguished using additional means, e.g. by position.
1085:
1086: The name of the local may be preceded by a type specifier, e.g.,
1087: @code{F:} for a floating point value:
1088:
1089: @example
1090: : CX* @{ F: Ar F: Ai F: Br F: Bi -- Cr Ci @}
1091: \ complex multiplication
1092: Ar Br f* Ai Bi f* f-
1093: Ar Bi f* Ai Br f* f+ ;
1094: @end example
1095:
1096: Gforth currently supports cells (@code{W:}, @code{W^}), doubles
1097: (@code{D:}, @code{D^}), floats (@code{F:}, @code{F^}) and characters
1098: (@code{C:}, @code{C^}) in two flavours: a value-flavoured local (defined
1099: with @code{W:}, @code{D:} etc.) produces its value and can be changed
1100: with @code{TO}. A variable-flavoured local (defined with @code{W^} etc.)
1101: produces its address (which becomes invalid when the variable's scope is
1102: left). E.g., the standard word @code{emit} can be defined in therms of
1103: @code{type} like this:
1104:
1105: @example
1106: : emit @{ C^ char* -- @}
1107: char* 1 type ;
1108: @end example
1109:
1110: A local without type specifier is a @code{W:} local. Both flavours of
1111: locals are initialized with values from the data or FP stack.
1112:
1113: Currently there is no way to define locals with user-defined data
1114: structures, but we are working on it.
1115:
1116: Gforth allows defining locals everywhere in a colon definition. This
1117: poses the following questions:
1118:
1119: @menu
1120: * Where are locals visible by name?::
1121: * How long do locals live?::
1122: * Programming Style::
1123: * Implementation::
1124: @end menu
1125:
1126: @node Where are locals visible by name?, How long do locals live?, Gforth locals, Gforth locals
1127: @subsubsection Where are locals visible by name?
1128:
1129: Basically, the answer is that locals are visible where you would expect
1130: it in block-structured languages, and sometimes a little longer. If you
1131: want to restrict the scope of a local, enclose its definition in
1132: @code{SCOPE}...@code{ENDSCOPE}.
1133:
1134: doc-scope
1135: doc-endscope
1136:
1137: These words behave like control structure words, so you can use them
1138: with @code{CS-PICK} and @code{CS-ROLL} to restrict the scope in
1139: arbitrary ways.
1140:
1141: If you want a more exact answer to the visibility question, here's the
1142: basic principle: A local is visible in all places that can only be
1143: reached through the definition of the local@footnote{In compiler
1144: construction terminology, all places dominated by the definition of the
1145: local.}. In other words, it is not visible in places that can be reached
1146: without going through the definition of the local. E.g., locals defined
1147: in @code{IF}...@code{ENDIF} are visible until the @code{ENDIF}, locals
1148: defined in @code{BEGIN}...@code{UNTIL} are visible after the
1149: @code{UNTIL} (until, e.g., a subsequent @code{ENDSCOPE}).
1150:
1151: The reasoning behind this solution is: We want to have the locals
1152: visible as long as it is meaningful. The user can always make the
1153: visibility shorter by using explicit scoping. In a place that can
1154: only be reached through the definition of a local, the meaning of a
1155: local name is clear. In other places it is not: How is the local
1156: initialized at the control flow path that does not contain the
1157: definition? Which local is meant, if the same name is defined twice in
1158: two independent control flow paths?
1159:
1160: This should be enough detail for nearly all users, so you can skip the
1161: rest of this section. If you relly must know all the gory details and
1162: options, read on.
1163:
1164: In order to implement this rule, the compiler has to know which places
1165: are unreachable. It knows this automatically after @code{AHEAD},
1166: @code{AGAIN}, @code{EXIT} and @code{LEAVE}; in other cases (e.g., after
1167: most @code{THROW}s), you can use the word @code{UNREACHABLE} to tell the
1168: compiler that the control flow never reaches that place. If
1169: @code{UNREACHABLE} is not used where it could, the only consequence is
1170: that the visibility of some locals is more limited than the rule above
1171: says. If @code{UNREACHABLE} is used where it should not (i.e., if you
1172: lie to the compiler), buggy code will be produced.
1173:
1174: Another problem with this rule is that at @code{BEGIN}, the compiler
1175: does not know which locals will be visible on the incoming
1176: back-edge. All problems discussed in the following are due to this
1177: ignorance of the compiler (we discuss the problems using @code{BEGIN}
1178: loops as examples; the discussion also applies to @code{?DO} and other
1179: loops). Perhaps the most insidious example is:
1180: @example
1181: AHEAD
1182: BEGIN
1183: x
1184: [ 1 CS-ROLL ] THEN
1185: @{ x @}
1186: ...
1187: UNTIL
1188: @end example
1189:
1190: This should be legal according to the visibility rule. The use of
1191: @code{x} can only be reached through the definition; but that appears
1192: textually below the use.
1193:
1194: From this example it is clear that the visibility rules cannot be fully
1195: implemented without major headaches. Our implementation treats common
1196: cases as advertised and the exceptions are treated in a safe way: The
1197: compiler makes a reasonable guess about the locals visible after a
1198: @code{BEGIN}; if it is too pessimistic, the
1199: user will get a spurious error about the local not being defined; if the
1200: compiler is too optimistic, it will notice this later and issue a
1201: warning. In the case above the compiler would complain about @code{x}
1202: being undefined at its use. You can see from the obscure examples in
1203: this section that it takes quite unusual control structures to get the
1204: compiler into trouble, and even then it will often do fine.
1205:
1206: If the @code{BEGIN} is reachable from above, the most optimistic guess
1207: is that all locals visible before the @code{BEGIN} will also be
1208: visible after the @code{BEGIN}. This guess is valid for all loops that
1209: are entered only through the @code{BEGIN}, in particular, for normal
1210: @code{BEGIN}...@code{WHILE}...@code{REPEAT} and
1211: @code{BEGIN}...@code{UNTIL} loops and it is implemented in our
1212: compiler. When the branch to the @code{BEGIN} is finally generated by
1213: @code{AGAIN} or @code{UNTIL}, the compiler checks the guess and
1214: warns the user if it was too optimisitic:
1215: @example
1216: IF
1217: @{ x @}
1218: BEGIN
1219: \ x ?
1220: [ 1 cs-roll ] THEN
1221: ...
1222: UNTIL
1223: @end example
1224:
1225: Here, @code{x} lives only until the @code{BEGIN}, but the compiler
1226: optimistically assumes that it lives until the @code{THEN}. It notices
1227: this difference when it compiles the @code{UNTIL} and issues a
1228: warning. The user can avoid the warning, and make sure that @code{x}
1229: is not used in the wrong area by using explicit scoping:
1230: @example
1231: IF
1232: SCOPE
1233: @{ x @}
1234: ENDSCOPE
1235: BEGIN
1236: [ 1 cs-roll ] THEN
1237: ...
1238: UNTIL
1239: @end example
1240:
1241: Since the guess is optimistic, there will be no spurious error messages
1242: about undefined locals.
1243:
1244: If the @code{BEGIN} is not reachable from above (e.g., after
1245: @code{AHEAD} or @code{EXIT}), the compiler cannot even make an
1246: optimistic guess, as the locals visible after the @code{BEGIN} may be
1247: defined later. Therefore, the compiler assumes that no locals are
1248: visible after the @code{BEGIN}. However, the user can use
1249: @code{ASSUME-LIVE} to make the compiler assume that the same locals are
1250: visible at the BEGIN as at the point where the top control-flow stack
1251: item was created.
1252:
1253: doc-assume-live
1254:
1255: E.g.,
1256: @example
1257: @{ x @}
1258: AHEAD
1259: ASSUME-LIVE
1260: BEGIN
1261: x
1262: [ 1 CS-ROLL ] THEN
1263: ...
1264: UNTIL
1265: @end example
1266:
1267: Other cases where the locals are defined before the @code{BEGIN} can be
1268: handled by inserting an appropriate @code{CS-ROLL} before the
1269: @code{ASSUME-LIVE} (and changing the control-flow stack manipulation
1270: behind the @code{ASSUME-LIVE}).
1271:
1272: Cases where locals are defined after the @code{BEGIN} (but should be
1273: visible immediately after the @code{BEGIN}) can only be handled by
1274: rearranging the loop. E.g., the ``most insidious'' example above can be
1275: arranged into:
1276: @example
1277: BEGIN
1278: @{ x @}
1279: ... 0=
1280: WHILE
1281: x
1282: REPEAT
1283: @end example
1284:
1285: @node How long do locals live?, Programming Style, Where are locals visible by name?, Gforth locals
1286: @subsubsection How long do locals live?
1287:
1288: The right answer for the lifetime question would be: A local lives at
1289: least as long as it can be accessed. For a value-flavoured local this
1290: means: until the end of its visibility. However, a variable-flavoured
1291: local could be accessed through its address far beyond its visibility
1292: scope. Ultimately, this would mean that such locals would have to be
1293: garbage collected. Since this entails un-Forth-like implementation
1294: complexities, I adopted the same cowardly solution as some other
1295: languages (e.g., C): The local lives only as long as it is visible;
1296: afterwards its address is invalid (and programs that access it
1297: afterwards are erroneous).
1298:
1299: @node Programming Style, Implementation, How long do locals live?, Gforth locals
1300: @subsubsection Programming Style
1301:
1302: The freedom to define locals anywhere has the potential to change
1303: programming styles dramatically. In particular, the need to use the
1304: return stack for intermediate storage vanishes. Moreover, all stack
1305: manipulations (except @code{PICK}s and @code{ROLL}s with run-time
1306: determined arguments) can be eliminated: If the stack items are in the
1307: wrong order, just write a locals definition for all of them; then
1308: write the items in the order you want.
1309:
1310: This seems a little far-fetched and eliminating stack manipulations is
1311: unlikely to become a conscious programming objective. Still, the number
1312: of stack manipulations will be reduced dramatically if local variables
1313: are used liberally (e.g., compare @code{max} in @ref{Gforth locals} with
1314: a traditional implementation of @code{max}).
1315:
1316: This shows one potential benefit of locals: making Forth programs more
1317: readable. Of course, this benefit will only be realized if the
1318: programmers continue to honour the principle of factoring instead of
1319: using the added latitude to make the words longer.
1320:
1321: Using @code{TO} can and should be avoided. Without @code{TO},
1322: every value-flavoured local has only a single assignment and many
1323: advantages of functional languages apply to Forth. I.e., programs are
1324: easier to analyse, to optimize and to read: It is clear from the
1325: definition what the local stands for, it does not turn into something
1326: different later.
1327:
1328: E.g., a definition using @code{TO} might look like this:
1329: @example
1330: : strcmp @{ addr1 u1 addr2 u2 -- n @}
1331: u1 u2 min 0
1332: ?do
1333: addr1 c@ addr2 c@ - ?dup
1334: if
1335: unloop exit
1336: then
1337: addr1 char+ TO addr1
1338: addr2 char+ TO addr2
1339: loop
1340: u1 u2 - ;
1341: @end example
1342: Here, @code{TO} is used to update @code{addr1} and @code{addr2} at
1343: every loop iteration. @code{strcmp} is a typical example of the
1344: readability problems of using @code{TO}. When you start reading
1345: @code{strcmp}, you think that @code{addr1} refers to the start of the
1346: string. Only near the end of the loop you realize that it is something
1347: else.
1348:
1349: This can be avoided by defining two locals at the start of the loop that
1350: are initialized with the right value for the current iteration.
1351: @example
1352: : strcmp @{ addr1 u1 addr2 u2 -- n @}
1353: addr1 addr2
1354: u1 u2 min 0
1355: ?do @{ s1 s2 @}
1356: s1 c@ s2 c@ - ?dup
1357: if
1358: unloop exit
1359: then
1360: s1 char+ s2 char+
1361: loop
1362: 2drop
1363: u1 u2 - ;
1364: @end example
1365: Here it is clear from the start that @code{s1} has a different value
1366: in every loop iteration.
1367:
1368: @node Implementation, , Programming Style, Gforth locals
1369: @subsubsection Implementation
1370:
1371: Gforth uses an extra locals stack. The most compelling reason for
1372: this is that the return stack is not float-aligned; using an extra stack
1373: also eliminates the problems and restrictions of using the return stack
1374: as locals stack. Like the other stacks, the locals stack grows toward
1375: lower addresses. A few primitives allow an efficient implementation:
1376:
1377: doc-@local#
1378: doc-f@local#
1379: doc-laddr#
1380: doc-lp+!#
1381: doc-lp!
1382: doc->l
1383: doc-f>l
1384:
1385: In addition to these primitives, some specializations of these
1386: primitives for commonly occurring inline arguments are provided for
1387: efficiency reasons, e.g., @code{@@local0} as specialization of
1388: @code{@@local#} for the inline argument 0. The following compiling words
1389: compile the right specialized version, or the general version, as
1390: appropriate:
1391:
1392: doc-compile-@local
1393: doc-compile-f@local
1394: doc-compile-lp+!
1395:
1396: Combinations of conditional branches and @code{lp+!#} like
1397: @code{?branch-lp+!#} (the locals pointer is only changed if the branch
1398: is taken) are provided for efficiency and correctness in loops.
1399:
1400: A special area in the dictionary space is reserved for keeping the
1401: local variable names. @code{@{} switches the dictionary pointer to this
1402: area and @code{@}} switches it back and generates the locals
1403: initializing code. @code{W:} etc.@ are normal defining words. This
1404: special area is cleared at the start of every colon definition.
1405:
1406: A special feature of Gforth's dictionary is used to implement the
1407: definition of locals without type specifiers: every wordlist (aka
1408: vocabulary) has its own methods for searching
1409: etc. (@pxref{Wordlists}). For the present purpose we defined a wordlist
1410: with a special search method: When it is searched for a word, it
1411: actually creates that word using @code{W:}. @code{@{} changes the search
1412: order to first search the wordlist containing @code{@}}, @code{W:} etc.,
1413: and then the wordlist for defining locals without type specifiers.
1414:
1415: The lifetime rules support a stack discipline within a colon
1416: definition: The lifetime of a local is either nested with other locals
1417: lifetimes or it does not overlap them.
1418:
1419: At @code{BEGIN}, @code{IF}, and @code{AHEAD} no code for locals stack
1420: pointer manipulation is generated. Between control structure words
1421: locals definitions can push locals onto the locals stack. @code{AGAIN}
1422: is the simplest of the other three control flow words. It has to
1423: restore the locals stack depth of the corresponding @code{BEGIN}
1424: before branching. The code looks like this:
1425: @format
1426: @code{lp+!#} current-locals-size @minus{} dest-locals-size
1427: @code{branch} <begin>
1428: @end format
1429:
1430: @code{UNTIL} is a little more complicated: If it branches back, it
1431: must adjust the stack just like @code{AGAIN}. But if it falls through,
1432: the locals stack must not be changed. The compiler generates the
1433: following code:
1434: @format
1435: @code{?branch-lp+!#} <begin> current-locals-size @minus{} dest-locals-size
1436: @end format
1437: The locals stack pointer is only adjusted if the branch is taken.
1438:
1439: @code{THEN} can produce somewhat inefficient code:
1440: @format
1441: @code{lp+!#} current-locals-size @minus{} orig-locals-size
1442: <orig target>:
1443: @code{lp+!#} orig-locals-size @minus{} new-locals-size
1444: @end format
1445: The second @code{lp+!#} adjusts the locals stack pointer from the
1446: level at the @var{orig} point to the level after the @code{THEN}. The
1447: first @code{lp+!#} adjusts the locals stack pointer from the current
1448: level to the level at the orig point, so the complete effect is an
1449: adjustment from the current level to the right level after the
1450: @code{THEN}.
1451:
1452: In a conventional Forth implementation a dest control-flow stack entry
1453: is just the target address and an orig entry is just the address to be
1454: patched. Our locals implementation adds a wordlist to every orig or dest
1455: item. It is the list of locals visible (or assumed visible) at the point
1456: described by the entry. Our implementation also adds a tag to identify
1457: the kind of entry, in particular to differentiate between live and dead
1458: (reachable and unreachable) orig entries.
1459:
1460: A few unusual operations have to be performed on locals wordlists:
1461:
1462: doc-common-list
1463: doc-sub-list?
1464: doc-list-size
1465:
1466: Several features of our locals wordlist implementation make these
1467: operations easy to implement: The locals wordlists are organised as
1468: linked lists; the tails of these lists are shared, if the lists
1469: contain some of the same locals; and the address of a name is greater
1470: than the address of the names behind it in the list.
1471:
1472: Another important implementation detail is the variable
1473: @code{dead-code}. It is used by @code{BEGIN} and @code{THEN} to
1474: determine if they can be reached directly or only through the branch
1475: that they resolve. @code{dead-code} is set by @code{UNREACHABLE},
1476: @code{AHEAD}, @code{EXIT} etc., and cleared at the start of a colon
1477: definition, by @code{BEGIN} and usually by @code{THEN}.
1478:
1479: Counted loops are similar to other loops in most respects, but
1480: @code{LEAVE} requires special attention: It performs basically the same
1481: service as @code{AHEAD}, but it does not create a control-flow stack
1482: entry. Therefore the information has to be stored elsewhere;
1483: traditionally, the information was stored in the target fields of the
1484: branches created by the @code{LEAVE}s, by organizing these fields into a
1485: linked list. Unfortunately, this clever trick does not provide enough
1486: space for storing our extended control flow information. Therefore, we
1487: introduce another stack, the leave stack. It contains the control-flow
1488: stack entries for all unresolved @code{LEAVE}s.
1489:
1490: Local names are kept until the end of the colon definition, even if
1491: they are no longer visible in any control-flow path. In a few cases
1492: this may lead to increased space needs for the locals name area, but
1493: usually less than reclaiming this space would cost in code size.
1494:
1495:
1496: @node ANS Forth locals, , Gforth locals, Locals
1497: @subsection ANS Forth locals
1498:
1499: The ANS Forth locals wordset does not define a syntax for locals, but
1500: words that make it possible to define various syntaxes. One of the
1501: possible syntaxes is a subset of the syntax we used in the Gforth locals
1502: wordset, i.e.:
1503:
1504: @example
1505: @{ local1 local2 ... -- comment @}
1506: @end example
1507: or
1508: @example
1509: @{ local1 local2 ... @}
1510: @end example
1511:
1512: The order of the locals corresponds to the order in a stack comment. The
1513: restrictions are:
1514:
1515: @itemize @bullet
1516: @item
1517: Locals can only be cell-sized values (no type specifiers are allowed).
1518: @item
1519: Locals can be defined only outside control structures.
1520: @item
1521: Locals can interfere with explicit usage of the return stack. For the
1522: exact (and long) rules, see the standard. If you don't use return stack
1523: accessing words in a definition using locals, you will be all right. The
1524: purpose of this rule is to make locals implementation on the return
1525: stack easier.
1526: @item
1527: The whole definition must be in one line.
1528: @end itemize
1529:
1530: Locals defined in this way behave like @code{VALUE}s
1531: (@xref{Values}). I.e., they are initialized from the stack. Using their
1532: name produces their value. Their value can be changed using @code{TO}.
1533:
1534: Since this syntax is supported by Gforth directly, you need not do
1535: anything to use it. If you want to port a program using this syntax to
1536: another ANS Forth system, use @file{anslocal.fs} to implement the syntax
1537: on the other system.
1538:
1539: Note that a syntax shown in the standard, section A.13 looks
1540: similar, but is quite different in having the order of locals
1541: reversed. Beware!
1542:
1543: The ANS Forth locals wordset itself consists of the following word
1544:
1545: doc-(local)
1546:
1547: The ANS Forth locals extension wordset defines a syntax, but it is so
1548: awful that we strongly recommend not to use it. We have implemented this
1549: syntax to make porting to Gforth easy, but do not document it here. The
1550: problem with this syntax is that the locals are defined in an order
1551: reversed with respect to the standard stack comment notation, making
1552: programs harder to read, and easier to misread and miswrite. The only
1553: merit of this syntax is that it is easy to implement using the ANS Forth
1554: locals wordset.
1555:
1556: @node Defining Words, Wordlists, Locals, Words
1557: @section Defining Words
1558:
1559: @menu
1560: * Values::
1561: @end menu
1562:
1563: @node Values, , Defining Words, Defining Words
1564: @subsection Values
1565:
1566: @node Wordlists, Files, Defining Words, Words
1567: @section Wordlists
1568:
1569: @node Files, Blocks, Wordlists, Words
1570: @section Files
1571:
1572: @node Blocks, Other I/O, Files, Words
1573: @section Blocks
1574:
1575: @node Other I/O, Programming Tools, Blocks, Words
1576: @section Other I/O
1577:
1578: @node Programming Tools, Assembler and Code words, Other I/O, Words
1579: @section Programming Tools
1580:
1581: @menu
1582: * Debugging:: Simple and quick.
1583: * Assertions:: Making your programs self-checking.
1584: @end menu
1585:
1586: @node Debugging, Assertions, Programming Tools, Programming Tools
1587: @subsection Debugging
1588:
1589: The simple debugging aids provided in @file{debugging.fs}
1590: are meant to support a different style of debugging than the
1591: tracing/stepping debuggers used in languages with long turn-around
1592: times.
1593:
1594: A much better (faster) way in fast-compilig languages is to add
1595: printing code at well-selected places, let the program run, look at
1596: the output, see where things went wrong, add more printing code, etc.,
1597: until the bug is found.
1598:
1599: The word @code{~~} is easy to insert. It just prints debugging
1600: information (by default the source location and the stack contents). It
1601: is also easy to remove (@kbd{C-x ~} in the Emacs Forth mode to
1602: query-replace them with nothing). The deferred words
1603: @code{printdebugdata} and @code{printdebugline} control the output of
1604: @code{~~}. The default source location output format works well with
1605: Emacs' compilation mode, so you can step through the program at the
1606: source level using @kbd{C-x `} (the advantage over a stepping debugger
1607: is that you can step in any direction and you know where the crash has
1608: happened or where the strange data has occurred).
1609:
1610: Note that the default actions clobber the contents of the pictured
1611: numeric output string, so you should not use @code{~~}, e.g., between
1612: @code{<#} and @code{#>}.
1613:
1614: doc-~~
1615: doc-printdebugdata
1616: doc-printdebugline
1617:
1618: @node Assertions, , Debugging, Programming Tools
1619: @subsection Assertions
1620:
1621: It is a good idea to make your programs self-checking, in particular, if
1622: you use an assumption (e.g., that a certain field of a data structure is
1623: never zero) that may become wrong during maintenance. Gforth supports
1624: assertions for this purpose. They are used like this:
1625:
1626: @example
1627: assert( @var{flag} )
1628: @end example
1629:
1630: The code between @code{assert(} and @code{)} should compute a flag, that
1631: should be true if everything is alright and false otherwise. It should
1632: not change anything else on the stack. The overall stack effect of the
1633: assertion is @code{( -- )}. E.g.
1634:
1635: @example
1636: assert( 1 1 + 2 = ) \ what we learn in school
1637: assert( dup 0<> ) \ assert that the top of stack is not zero
1638: assert( false ) \ this code should not be reached
1639: @end example
1640:
1641: The need for assertions is different at different times. During
1642: debugging, we want more checking, in production we sometimes care more
1643: for speed. Therefore, assertions can be turned off, i.e., the assertion
1644: becomes a comment. Depending on the importance of an assertion and the
1645: time it takes to check it, you may want to turn off some assertions and
1646: keep others turned on. Gforth provides several levels of assertions for
1647: this purpose:
1648:
1649: doc-assert0(
1650: doc-assert1(
1651: doc-assert2(
1652: doc-assert3(
1653: doc-assert(
1654: doc-)
1655:
1656: @code{Assert(} is the same as @code{assert1(}. The variable
1657: @code{assert-level} specifies the highest assertions that are turned
1658: on. I.e., at the default @code{assert-level} of one, @code{assert0(} and
1659: @code{assert1(} assertions perform checking, while @code{assert2(} and
1660: @code{assert3(} assertions are treated as comments.
1661:
1662: Note that the @code{assert-level} is evaluated at compile-time, not at
1663: run-time. I.e., you cannot turn assertions on or off at run-time, you
1664: have to set the @code{assert-level} appropriately before compiling a
1665: piece of code. You can compile several pieces of code at several
1666: @code{assert-level}s (e.g., a trusted library at level 1 and newly
1667: written code at level 3).
1668:
1669: doc-assert-level
1670:
1671: If an assertion fails, a message compatible with Emacs' compilation mode
1672: is produced and the execution is aborted (currently with @code{ABORT"}.
1673: If there is interest, we will introduce a special throw code. But if you
1674: intend to @code{catch} a specific condition, using @code{throw} is
1675: probably more appropriate than an assertion).
1676:
1677: @node Assembler and Code words, Threading Words, Programming Tools, Words
1678: @section Assembler and Code words
1679:
1680: Gforth provides some words for defining primitives (words written in
1681: machine code), and for defining the the machine-code equivalent of
1682: @code{DOES>}-based defining words. However, the machine-independent
1683: nature of Gforth poses a few problems: First of all. Gforth runs on
1684: several architectures, so it can provide no standard assembler. What's
1685: worse is that the register allocation not only depends on the processor,
1686: but also on the gcc version and options used.
1687:
1688: The words Gforth offers encapsulate some system dependences (e.g., the
1689: header structure), so a system-independent assembler may be used in
1690: Gforth. If you do not have an assembler, you can compile machine code
1691: directly with @code{,} and @code{c,}.
1692:
1693: doc-assembler
1694: doc-code
1695: doc-end-code
1696: doc-;code
1697: doc-flush-icache
1698:
1699: If @code{flush-icache} does not work correctly, @code{code} words
1700: etc. will not work (reliably), either.
1701:
1702: These words are rarely used. Therefore they reside in @code{code.fs},
1703: which is usually not loaded (except @code{flush-icache}, which is always
1704: present). You can load them with @code{require code.fs}.
1705:
1706: Another option for implementing normal and defining words efficiently
1707: is: adding the wanted functionality to the source of Gforth. For normal
1708: words you just have to edit @file{primitives}, defining words (for fast
1709: defined words) probably require changes in @file{engine.c},
1710: @file{kernal.fs}, @file{prims2x.fs}, and possibly @file{cross.fs}.
1711:
1712:
1713: @node Threading Words, , Assembler and Code words, Words
1714: @section Threading Words
1715:
1716: These words provide access to code addresses and other threading stuff
1717: in Gforth (and, possibly, other interpretive Forths). It more or less
1718: abstracts away the differences between direct and indirect threading
1719: (and, for direct threading, the machine dependences). However, at
1720: present this wordset is still inclomplete. It is also pretty low-level;
1721: some day it will hopefully be made unnecessary by an internals words set
1722: that abstracts implementation details away completely.
1723:
1724: doc->code-address
1725: doc->does-code
1726: doc-code-address!
1727: doc-does-code!
1728: doc-does-handler!
1729: doc-/does-handler
1730:
1731: The code addresses produced by various defining words are produced by
1732: the following words:
1733:
1734: doc-docol:
1735: doc-docon:
1736: doc-dovar:
1737: doc-douser:
1738: doc-dodefer:
1739: doc-dofield:
1740:
1741: Currently there is no installation-independent way for recogizing words
1742: defined by a @code{CREATE}...@code{DOES>} word; however, once you know
1743: that a word is defined by a @code{CREATE}...@code{DOES>} word, you can
1744: use @code{>DOES-CODE}.
1745:
1746: @node ANS conformance, Model, Words, Top
1747: @chapter ANS conformance
1748:
1749: To the best of our knowledge, Gforth is an
1750:
1751: ANS Forth System
1752: @itemize
1753: @item providing the Core Extensions word set
1754: @item providing the Block word set
1755: @item providing the Block Extensions word set
1756: @item providing the Double-Number word set
1757: @item providing the Double-Number Extensions word set
1758: @item providing the Exception word set
1759: @item providing the Exception Extensions word set
1760: @item providing the Facility word set
1761: @item providing @code{MS} and @code{TIME&DATE} from the Facility Extensions word set
1762: @item providing the File Access word set
1763: @item providing the File Access Extensions word set
1764: @item providing the Floating-Point word set
1765: @item providing the Floating-Point Extensions word set
1766: @item providing the Locals word set
1767: @item providing the Locals Extensions word set
1768: @item providing the Memory-Allocation word set
1769: @item providing the Memory-Allocation Extensions word set (that one's easy)
1770: @item providing the Programming-Tools word set
1771: @item providing @code{;code}, @code{AHEAD}, @code{ASSEMBLER}, @code{BYE}, @code{CODE}, @code{CS-PICK}, @code{CS-ROLL}, @code{STATE}, @code{[ELSE]}, @code{[IF]}, @code{[THEN]} from the Programming-Tools Extensions word set
1772: @item providing the Search-Order word set
1773: @item providing the Search-Order Extensions word set
1774: @item providing the String word set
1775: @item providing the String Extensions word set (another easy one)
1776: @end itemize
1777:
1778: In addition, ANS Forth systems are required to document certain
1779: implementation choices. This chapter tries to meet these
1780: requirements. In many cases it gives a way to ask the system for the
1781: information instead of providing the information directly, in
1782: particular, if the information depends on the processor, the operating
1783: system or the installation options chosen, or if they are likely to
1784: change during the maintenance of Gforth.
1785:
1786: @comment The framework for the rest has been taken from pfe.
1787:
1788: @menu
1789: * The Core Words::
1790: * The optional Block word set::
1791: * The optional Double Number word set::
1792: * The optional Exception word set::
1793: * The optional Facility word set::
1794: * The optional File-Access word set::
1795: * The optional Floating-Point word set::
1796: * The optional Locals word set::
1797: * The optional Memory-Allocation word set::
1798: * The optional Programming-Tools word set::
1799: * The optional Search-Order word set::
1800: @end menu
1801:
1802:
1803: @c =====================================================================
1804: @node The Core Words, The optional Block word set, ANS conformance, ANS conformance
1805: @comment node-name, next, previous, up
1806: @section The Core Words
1807: @c =====================================================================
1808:
1809: @menu
1810: * core-idef:: Implementation Defined Options
1811: * core-ambcond:: Ambiguous Conditions
1812: * core-other:: Other System Documentation
1813: @end menu
1814:
1815: @c ---------------------------------------------------------------------
1816: @node core-idef, core-ambcond, The Core Words, The Core Words
1817: @subsection Implementation Defined Options
1818: @c ---------------------------------------------------------------------
1819:
1820: @table @i
1821:
1822: @item (Cell) aligned addresses:
1823: processor-dependent. Gforth's alignment words perform natural alignment
1824: (e.g., an address aligned for a datum of size 8 is divisible by
1825: 8). Unaligned accesses usually result in a @code{-23 THROW}.
1826:
1827: @item @code{EMIT} and non-graphic characters:
1828: The character is output using the C library function (actually, macro)
1829: @code{putchar}.
1830:
1831: @item character editing of @code{ACCEPT} and @code{EXPECT}:
1832: This is modeled on the GNU readline library (@pxref{Readline
1833: Interaction, , Command Line Editing, readline, The GNU Readline
1834: Library}) with Emacs-like key bindings. @kbd{Tab} deviates a little by
1835: producing a full word completion every time you type it (instead of
1836: producing the common prefix of all completions).
1837:
1838: @item character set:
1839: The character set of your computer and display device. Gforth is
1840: 8-bit-clean (but some other component in your system may make trouble).
1841:
1842: @item Character-aligned address requirements:
1843: installation-dependent. Currently a character is represented by a C
1844: @code{unsigned char}; in the future we might switch to @code{wchar_t}
1845: (Comments on that requested).
1846:
1847: @item character-set extensions and matching of names:
1848: Any character except the ASCII NUL charcter can be used in a
1849: name. Matching is case-insensitive. The matching is performed using the
1850: C function @code{strncasecmp}, whose function is probably influenced by
1851: the locale. E.g., the @code{C} locale does not know about accents and
1852: umlauts, so they are matched case-sensitively in that locale. For
1853: portability reasons it is best to write programs such that they work in
1854: the @code{C} locale. Then one can use libraries written by a Polish
1855: programmer (who might use words containing ISO Latin-2 encoded
1856: characters) and by a French programmer (ISO Latin-1) in the same program
1857: (of course, @code{WORDS} will produce funny results for some of the
1858: words (which ones, depends on the font you are using)). Also, the locale
1859: you prefer may not be available in other operating systems. Hopefully,
1860: Unicode will solve these problems one day.
1861:
1862: @item conditions under which control characters match a space delimiter:
1863: If @code{WORD} is called with the space character as a delimiter, all
1864: white-space characters (as identified by the C macro @code{isspace()})
1865: are delimiters. @code{PARSE}, on the other hand, treats space like other
1866: delimiters. @code{PARSE-WORD} treats space like @code{WORD}, but behaves
1867: like @code{PARSE} otherwise. @code{(NAME)}, which is used by the outer
1868: interpreter (aka text interpreter) by default, treats all white-space
1869: characters as delimiters.
1870:
1871: @item format of the control flow stack:
1872: The data stack is used as control flow stack. The size of a control flow
1873: stack item in cells is given by the constant @code{cs-item-size}. At the
1874: time of this writing, an item consists of a (pointer to a) locals list
1875: (third), an address in the code (second), and a tag for identifying the
1876: item (TOS). The following tags are used: @code{defstart},
1877: @code{live-orig}, @code{dead-orig}, @code{dest}, @code{do-dest},
1878: @code{scopestart}.
1879:
1880: @item conversion of digits > 35
1881: The characters @code{[\]^_'} are the digits with the decimal value
1882: 36@minus{}41. There is no way to input many of the larger digits.
1883:
1884: @item display after input terminates in @code{ACCEPT} and @code{EXPECT}:
1885: The cursor is moved to the end of the entered string. If the input is
1886: terminated using the @kbd{Return} key, a space is typed.
1887:
1888: @item exception abort sequence of @code{ABORT"}:
1889: The error string is stored into the variable @code{"error} and a
1890: @code{-2 throw} is performed.
1891:
1892: @item input line terminator:
1893: For interactive input, @kbd{C-m} and @kbd{C-j} terminate lines. One of
1894: these characters is typically produced when you type the @kbd{Enter} or
1895: @kbd{Return} key.
1896:
1897: @item maximum size of a counted string:
1898: @code{s" /counted-string" environment? drop .}. Currently 255 characters
1899: on all ports, but this may change.
1900:
1901: @item maximum size of a parsed string:
1902: Given by the constant @code{/line}. Currently 255 characters.
1903:
1904: @item maximum size of a definition name, in characters:
1905: 31
1906:
1907: @item maximum string length for @code{ENVIRONMENT?}, in characters:
1908: 31
1909:
1910: @item method of selecting the user input device:
1911: The user input device is the standard input. There is currently no way to
1912: change it from within Gforth. However, the input can typically be
1913: redirected in the command line that starts Gforth.
1914:
1915: @item method of selecting the user output device:
1916: The user output device is the standard output. It cannot be redirected
1917: from within Gforth, but typically from the command line that starts
1918: Gforth. Gforth uses buffered output, so output on a terminal does not
1919: become visible before the next newline or buffer overflow. Output on
1920: non-terminals is invisible until the buffer overflows.
1921:
1922: @item methods of dictionary compilation:
1923: What are we expected to document here?
1924:
1925: @item number of bits in one address unit:
1926: @code{s" address-units-bits" environment? drop .}. 8 in all current
1927: ports.
1928:
1929: @item number representation and arithmetic:
1930: Processor-dependent. Binary two's complement on all current ports.
1931:
1932: @item ranges for integer types:
1933: Installation-dependent. Make environmental queries for @code{MAX-N},
1934: @code{MAX-U}, @code{MAX-D} and @code{MAX-UD}. The lower bounds for
1935: unsigned (and positive) types is 0. The lower bound for signed types on
1936: two's complement and one's complement machines machines can be computed
1937: by adding 1 to the upper bound.
1938:
1939: @item read-only data space regions:
1940: The whole Forth data space is writable.
1941:
1942: @item size of buffer at @code{WORD}:
1943: @code{PAD HERE - .}. 104 characters on 32-bit machines. The buffer is
1944: shared with the pictured numeric output string. If overwriting
1945: @code{PAD} is acceptable, it is as large as the remaining dictionary
1946: space, although only as much can be sensibly used as fits in a counted
1947: string.
1948:
1949: @item size of one cell in address units:
1950: @code{1 cells .}.
1951:
1952: @item size of one character in address units:
1953: @code{1 chars .}. 1 on all current ports.
1954:
1955: @item size of the keyboard terminal buffer:
1956: Varies. You can determine the size at a specific time using @code{lp@
1957: tib - .}. It is shared with the locals stack and TIBs of files that
1958: include the current file. You can change the amount of space for TIBs
1959: and locals stack at Gforth startup with the command line option
1960: @code{-l}.
1961:
1962: @item size of the pictured numeric output buffer:
1963: @code{PAD HERE - .}. 104 characters on 32-bit machines. The buffer is
1964: shared with @code{WORD}.
1965:
1966: @item size of the scratch area returned by @code{PAD}:
1967: The remainder of dictionary space. You can even use the unused part of
1968: the data stack space. The current size can be computed with @code{sp@
1969: pad - .}.
1970:
1971: @item system case-sensitivity characteristics:
1972: Dictionary searches are case insensitive. However, as explained above
1973: under @i{character-set extensions}, the matching for non-ASCII
1974: characters is determined by the locale you are using. In the default
1975: @code{C} locale all non-ASCII characters are matched case-sensitively.
1976:
1977: @item system prompt:
1978: @code{ ok} in interpret state, @code{ compiled} in compile state.
1979:
1980: @item division rounding:
1981: installation dependent. @code{s" floored" environment? drop .}. We leave
1982: the choice to gcc (what to use for @code{/}) and to you (whether to use
1983: @code{fm/mod}, @code{sm/rem} or simply @code{/}).
1984:
1985: @item values of @code{STATE} when true:
1986: -1.
1987:
1988: @item values returned after arithmetic overflow:
1989: On two's complement machines, arithmetic is performed modulo
1990: 2**bits-per-cell for single arithmetic and 4**bits-per-cell for double
1991: arithmetic (with appropriate mapping for signed types). Division by zero
1992: typically results in a @code{-55 throw} (floatingpoint unidentified
1993: fault), although a @code{-10 throw} (divide by zero) would be more
1994: appropriate.
1995:
1996: @item whether the current definition can be found after @t{DOES>}:
1997: No.
1998:
1999: @end table
2000:
2001: @c ---------------------------------------------------------------------
2002: @node core-ambcond, core-other, core-idef, The Core Words
2003: @subsection Ambiguous conditions
2004: @c ---------------------------------------------------------------------
2005:
2006: @table @i
2007:
2008: @item a name is neither a word nor a number:
2009: @code{-13 throw} (Undefined word)
2010:
2011: @item a definition name exceeds the maximum length allowed:
2012: @code{-19 throw} (Word name too long)
2013:
2014: @item addressing a region not inside the various data spaces of the forth system:
2015: The stacks, code space and name space are accessible. Machine code space is
2016: typically readable. Accessing other addresses gives results dependent on
2017: the operating system. On decent systems: @code{-9 throw} (Invalid memory
2018: address).
2019:
2020: @item argument type incompatible with parameter:
2021: This is usually not caught. Some words perform checks, e.g., the control
2022: flow words, and issue a @code{ABORT"} or @code{-12 THROW} (Argument type
2023: mismatch).
2024:
2025: @item attempting to obtain the execution token of a word with undefined execution semantics:
2026: You get an execution token representing the compilation semantics
2027: instead.
2028:
2029: @item dividing by zero:
2030: typically results in a @code{-55 throw} (floating point unidentified
2031: fault), although a @code{-10 throw} (divide by zero) would be more
2032: appropriate.
2033:
2034: @item insufficient data stack or return stack space:
2035: Not checked. This typically results in mysterious illegal memory
2036: accesses, producing @code{-9 throw} (Invalid memory address) or
2037: @code{-23 throw} (Address alignment exception).
2038:
2039: @item insufficient space for loop control parameters:
2040: like other return stack overflows.
2041:
2042: @item insufficient space in the dictionary:
2043: Not checked. Similar results as stack overflows. However, typically the
2044: error appears at a different place when one inserts or removes code.
2045:
2046: @item interpreting a word with undefined interpretation semantics:
2047: For some words, we defined interpretation semantics. For the others:
2048: @code{-14 throw} (Interpreting a compile-only word). Note that this is
2049: checked only by the outer (aka text) interpreter; if the word is
2050: @code{execute}d in some other way, it will typically perform it's
2051: compilation semantics even in interpret state. (We could change @code{'}
2052: and relatives not to give the xt of such words, but we think that would
2053: be too restrictive).
2054:
2055: @item modifying the contents of the input buffer or a string literal:
2056: These are located in writable memory and can be modified.
2057:
2058: @item overflow of the pictured numeric output string:
2059: Not checked.
2060:
2061: @item parsed string overflow:
2062: @code{PARSE} cannot overflow. @code{WORD} does not check for overflow.
2063:
2064: @item producing a result out of range:
2065: On two's complement machines, arithmetic is performed modulo
2066: 2**bits-per-cell for single arithmetic and 4**bits-per-cell for double
2067: arithmetic (with appropriate mapping for signed types). Division by zero
2068: typically results in a @code{-55 throw} (floatingpoint unidentified
2069: fault), although a @code{-10 throw} (divide by zero) would be more
2070: appropriate. @code{convert} and @code{>number} currently overflow
2071: silently.
2072:
2073: @item reading from an empty data or return stack:
2074: The data stack is checked by the outer (aka text) interpreter after
2075: every word executed. If it has underflowed, a @code{-4 throw} (Stack
2076: underflow) is performed. Apart from that, the stacks are not checked and
2077: underflows can result in similar behaviour as overflows (of adjacent
2078: stacks).
2079:
2080: @item unexepected end of the input buffer, resulting in an attempt to use a zero-length string as a name:
2081: @code{Create} and its descendants perform a @code{-16 throw} (Attempt to
2082: use zero-length string as a name). Words like @code{'} probably will not
2083: find what they search. Note that it is possible to create zero-length
2084: names with @code{nextname} (should it not?).
2085:
2086: @item @code{>IN} greater than input buffer:
2087: The next invocation of a parsing word returns a string wih length 0.
2088:
2089: @item @code{RECURSE} appears after @code{DOES>}:
2090: Compiles a recursive call to the defining word not to the defined word.
2091:
2092: @item argument input source different than current input source for @code{RESTORE-INPUT}:
2093: !!???If the argument input source is a valid input source then it gets
2094: restored. Otherwise causes @code{-12 THROW}, which, unless caught, issues
2095: the message "argument type mismatch" and aborts.
2096:
2097: @item data space containing definitions gets de-allocated:
2098: Deallocation with @code{allot} is not checked. This typically resuls in
2099: memory access faults or execution of illegal instructions.
2100:
2101: @item data space read/write with incorrect alignment:
2102: Processor-dependent. Typically results in a @code{-23 throw} (Address
2103: alignment exception). Under Linux on a 486 or later processor with
2104: alignment turned on, incorrect alignment results in a @code{-9 throw}
2105: (Invalid memory address). There are reportedly some processors with
2106: alignment restrictions that do not report them.
2107:
2108: @item data space pointer not properly aligned, @code{,}, @code{C,}:
2109: Like other alignment errors.
2110:
2111: @item less than u+2 stack items (@code{PICK} and @code{ROLL}):
2112: Not checked. May cause an illegal memory access.
2113:
2114: @item loop control parameters not available:
2115: Not checked. The counted loop words simply assume that the top of return
2116: stack items are loop control parameters and behave accordingly.
2117:
2118: @item most recent definition does not have a name (@code{IMMEDIATE}):
2119: @code{abort" last word was headerless"}.
2120:
2121: @item name not defined by @code{VALUE} used by @code{TO}:
2122: @code{-32 throw} (Invalid name argument)
2123:
2124: @item name not found (@code{'}, @code{POSTPONE}, @code{[']}, @code{[COMPILE]}):
2125: @code{-13 throw} (Undefined word)
2126:
2127: @item parameters are not of the same type (@code{DO}, @code{?DO}, @code{WITHIN}):
2128: Gforth behaves as if they were of the same type. I.e., you can predict
2129: the behaviour by interpreting all parameters as, e.g., signed.
2130:
2131: @item @code{POSTPONE} or @code{[COMPILE]} applied to @code{TO}:
2132: Assume @code{: X POSTPONE TO ; IMMEDIATE}. @code{X} is equivalent to
2133: @code{TO}.
2134:
2135: @item String longer than a counted string returned by @code{WORD}:
2136: Not checked. The string will be ok, but the count will, of course,
2137: contain only the least significant bits of the length.
2138:
2139: @item u greater than or equal to the number of bits in a cell (@code{LSHIFT}, @code{RSHIFT}):
2140: Processor-dependent. Typical behaviours are returning 0 and using only
2141: the low bits of the shift count.
2142:
2143: @item word not defined via @code{CREATE}:
2144: @code{>BODY} produces the PFA of the word no matter how it was defined.
2145:
2146: @code{DOES>} changes the execution semantics of the last defined word no
2147: matter how it was defined. E.g., @code{CONSTANT DOES>} is equivalent to
2148: @code{CREATE , DOES>}.
2149:
2150: @item words improperly used outside @code{<#} and @code{#>}:
2151: Not checked. As usual, you can expect memory faults.
2152:
2153: @end table
2154:
2155:
2156: @c ---------------------------------------------------------------------
2157: @node core-other, , core-ambcond, The Core Words
2158: @subsection Other system documentation
2159: @c ---------------------------------------------------------------------
2160:
2161: @table @i
2162:
2163: @item nonstandard words using @code{PAD}:
2164: None.
2165:
2166: @item operator's terminal facilities available:
2167: !!??
2168:
2169: @item program data space available:
2170: @code{sp@ here - .} gives the space remaining for dictionary and data
2171: stack together.
2172:
2173: @item return stack space available:
2174: !!??
2175:
2176: @item stack space available:
2177: @code{sp@ here - .} gives the space remaining for dictionary and data
2178: stack together.
2179:
2180: @item system dictionary space required, in address units:
2181: Type @code{here forthstart - .} after startup. At the time of this
2182: writing, this gives 70108 (bytes) on a 32-bit system.
2183: @end table
2184:
2185:
2186: @c =====================================================================
2187: @node The optional Block word set, The optional Double Number word set, The Core Words, ANS conformance
2188: @section The optional Block word set
2189: @c =====================================================================
2190:
2191: @menu
2192: * block-idef:: Implementation Defined Options
2193: * block-ambcond:: Ambiguous Conditions
2194: * block-other:: Other System Documentation
2195: @end menu
2196:
2197:
2198: @c ---------------------------------------------------------------------
2199: @node block-idef, block-ambcond, The optional Block word set, The optional Block word set
2200: @subsection Implementation Defined Options
2201: @c ---------------------------------------------------------------------
2202:
2203: @table @i
2204:
2205: @item the format for display by @code{LIST}:
2206: First the screen number is displayed, then 16 lines of 64 characters,
2207: each line preceded by the line number.
2208:
2209: @item the length of a line affected by @code{\}:
2210: 64 characters.
2211: @end table
2212:
2213:
2214: @c ---------------------------------------------------------------------
2215: @node block-ambcond, block-other, block-idef, The optional Block word set
2216: @subsection Ambiguous conditions
2217: @c ---------------------------------------------------------------------
2218:
2219: @table @i
2220:
2221: @item correct block read was not possible:
2222: Typically results in a @code{throw} of some OS-derived value (between
2223: -512 and -2048). If the blocks file was just not long enough, blanks are
2224: supplied for the missing portion.
2225:
2226: @item I/O exception in block transfer:
2227: Typically results in a @code{throw} of some OS-derived value (between
2228: -512 and -2048).
2229:
2230: @item invalid block number:
2231: @code{-35 throw} (Invalid block number)
2232:
2233: @item a program directly alters the contents of @code{BLK}:
2234: The input stream is switched to that other block, at the same
2235: position. If the storing to @code{BLK} happens when interpreting
2236: non-block input, the system will get quite confused when the block ends.
2237:
2238: @item no current block buffer for @code{UPDATE}:
2239: @code{UPDATE} has no effect.
2240:
2241: @end table
2242:
2243:
2244: @c ---------------------------------------------------------------------
2245: @node block-other, , block-ambcond, The optional Block word set
2246: @subsection Other system documentation
2247: @c ---------------------------------------------------------------------
2248:
2249: @table @i
2250:
2251: @item any restrictions a multiprogramming system places on the use of buffer addresses:
2252: No restrictions (yet).
2253:
2254: @item the number of blocks available for source and data:
2255: depends on your disk space.
2256:
2257: @end table
2258:
2259:
2260: @c =====================================================================
2261: @node The optional Double Number word set, The optional Exception word set, The optional Block word set, ANS conformance
2262: @section The optional Double Number word set
2263: @c =====================================================================
2264:
2265: @menu
2266: * double-ambcond:: Ambiguous Conditions
2267: @end menu
2268:
2269:
2270: @c ---------------------------------------------------------------------
2271: @node double-ambcond, , The optional Double Number word set, The optional Double Number word set
2272: @subsection Ambiguous conditions
2273: @c ---------------------------------------------------------------------
2274:
2275: @table @i
2276:
2277: @item @var{d} outside of range of @var{n} in @code{D>S}:
2278: The least significant cell of @var{d} is produced.
2279:
2280: @end table
2281:
2282:
2283: @c =====================================================================
2284: @node The optional Exception word set, The optional Facility word set, The optional Double Number word set, ANS conformance
2285: @section The optional Exception word set
2286: @c =====================================================================
2287:
2288: @menu
2289: * exception-idef:: Implementation Defined Options
2290: @end menu
2291:
2292:
2293: @c ---------------------------------------------------------------------
2294: @node exception-idef, , The optional Exception word set, The optional Exception word set
2295: @subsection Implementation Defined Options
2296: @c ---------------------------------------------------------------------
2297:
2298: @table @i
2299: @item @code{THROW}-codes used in the system:
2300: The codes -256@minus{}-511 are used for reporting signals (see
2301: @file{errore.fs}). The codes -512@minus{}-2047 are used for OS errors
2302: (for file and memory allocation operations). The mapping from OS error
2303: numbers to throw code is -512@minus{}@var{errno}. One side effect of
2304: this mapping is that undefined OS errors produce a message with a
2305: strange number; e.g., @code{-1000 THROW} results in @code{Unknown error
2306: 488} on my system.
2307: @end table
2308:
2309: @c =====================================================================
2310: @node The optional Facility word set, The optional File-Access word set, The optional Exception word set, ANS conformance
2311: @section The optional Facility word set
2312: @c =====================================================================
2313:
2314: @menu
2315: * facility-idef:: Implementation Defined Options
2316: * facility-ambcond:: Ambiguous Conditions
2317: @end menu
2318:
2319:
2320: @c ---------------------------------------------------------------------
2321: @node facility-idef, facility-ambcond, The optional Facility word set, The optional Facility word set
2322: @subsection Implementation Defined Options
2323: @c ---------------------------------------------------------------------
2324:
2325: @table @i
2326:
2327: @item encoding of keyboard events (@code{EKEY}):
2328: Not yet implemeted.
2329:
2330: @item duration of a system clock tick
2331: System dependent. With respect to @code{MS}, the time is specified in
2332: microseconds. How well the OS and the hardware implement this, is
2333: another question.
2334:
2335: @item repeatability to be expected from the execution of @code{MS}:
2336: System dependent. On Unix, a lot depends on load. If the system is
2337: lightly loaded, and the delay is short enough that Gforth does not get
2338: swapped out, the performance should be acceptable. Under MS-DOS and
2339: other single-tasking systems, it should be good.
2340:
2341: @end table
2342:
2343:
2344: @c ---------------------------------------------------------------------
2345: @node facility-ambcond, , facility-idef, The optional Facility word set
2346: @subsection Ambiguous conditions
2347: @c ---------------------------------------------------------------------
2348:
2349: @table @i
2350:
2351: @item @code{AT-XY} can't be performed on user output device:
2352: Largely terminal dependant. No range checks are done on the arguments.
2353: No errors are reported. You may see some garbage appearing, you may see
2354: simply nothing happen.
2355:
2356: @end table
2357:
2358:
2359: @c =====================================================================
2360: @node The optional File-Access word set, The optional Floating-Point word set, The optional Facility word set, ANS conformance
2361: @section The optional File-Access word set
2362: @c =====================================================================
2363:
2364: @menu
2365: * file-idef:: Implementation Defined Options
2366: * file-ambcond:: Ambiguous Conditions
2367: @end menu
2368:
2369:
2370: @c ---------------------------------------------------------------------
2371: @node file-idef, file-ambcond, The optional File-Access word set, The optional File-Access word set
2372: @subsection Implementation Defined Options
2373: @c ---------------------------------------------------------------------
2374:
2375: @table @i
2376:
2377: @item File access methods used:
2378: @code{R/O}, @code{R/W} and @code{BIN} work as you would
2379: expect. @code{W/O} translates into the C file opening mode @code{w} (or
2380: @code{wb}): The file is cleared, if it exists, and created, if it does
2381: not (both with @code{open-file} and @code{create-file}). Under Unix
2382: @code{create-file} creates a file with 666 permissions modified by your
2383: umask.
2384:
2385: @item file exceptions:
2386: The file words do not raise exceptions (except, perhaps, memory access
2387: faults when you pass illegal addresses or file-ids).
2388:
2389: @item file line terminator:
2390: System-dependent. Gforth uses C's newline character as line
2391: terminator. What the actual character code(s) of this are is
2392: system-dependent.
2393:
2394: @item file name format
2395: System dependent. Gforth just uses the file name format of your OS.
2396:
2397: @item information returned by @code{FILE-STATUS}:
2398: @code{FILE-STATUS} returns the most powerful file access mode allowed
2399: for the file: Either @code{R/O}, @code{W/O} or @code{R/W}. If the file
2400: cannot be accessed, @code{R/O BIN} is returned. @code{BIN} is applicable
2401: along with the retured mode.
2402:
2403: @item input file state after an exception when including source:
2404: All files that are left via the exception are closed.
2405:
2406: @item @var{ior} values and meaning:
2407: The @var{ior}s returned by the file and memory allocation words are
2408: intended as throw codes. They typically are in the range
2409: -512@minus{}-2047 of OS errors. The mapping from OS error numbers to
2410: @var{ior}s is -512@minus{}@var{errno}.
2411:
2412: @item maximum depth of file input nesting:
2413: limited by the amount of return stack, locals/TIB stack, and the number
2414: of open files available. This should not give you troubles.
2415:
2416: @item maximum size of input line:
2417: @code{/line}. Currently 255.
2418:
2419: @item methods of mapping block ranges to files:
2420: Currently, the block words automatically access the file
2421: @file{blocks.fb} in the currend working directory. More sophisticated
2422: methods could be implemented if there is demand (and a volunteer).
2423:
2424: @item number of string buffers provided by @code{S"}:
2425: 1
2426:
2427: @item size of string buffer used by @code{S"}:
2428: @code{/line}. currently 255.
2429:
2430: @end table
2431:
2432: @c ---------------------------------------------------------------------
2433: @node file-ambcond, , file-idef, The optional File-Access word set
2434: @subsection Ambiguous conditions
2435: @c ---------------------------------------------------------------------
2436:
2437: @table @i
2438:
2439: @item attempting to position a file outside it's boundaries:
2440: @code{REPOSITION-FILE} is performed as usual: Afterwards,
2441: @code{FILE-POSITION} returns the value given to @code{REPOSITION-FILE}.
2442:
2443: @item attempting to read from file positions not yet written:
2444: End-of-file, i.e., zero characters are read and no error is reported.
2445:
2446: @item @var{file-id} is invalid (@code{INCLUDE-FILE}):
2447: An appropriate exception may be thrown, but a memory fault or other
2448: problem is more probable.
2449:
2450: @item I/O exception reading or closing @var{file-id} (@code{include-file}, @code{included}):
2451: The @var{ior} produced by the operation, that discovered the problem, is
2452: thrown.
2453:
2454: @item named file cannot be opened (@code{included}):
2455: The @var{ior} produced by @code{open-file} is thrown.
2456:
2457: @item requesting an unmapped block number:
2458: There are no unmapped legal block numbers. On some operating systems,
2459: writing a block with a large number may overflow the file system and
2460: have an error message as consequence.
2461:
2462: @item using @code{source-id} when @code{blk} is non-zero:
2463: @code{source-id} performs its function. Typically it will give the id of
2464: the source which loaded the block. (Better ideas?)
2465:
2466: @end table
2467:
2468:
2469: @c =====================================================================
2470: @node The optional Floating-Point word set, The optional Locals word set, The optional File-Access word set, ANS conformance
2471: @section The optional Floating-Point word set
2472: @c =====================================================================
2473:
2474: @menu
2475: * floating-idef:: Implementation Defined Options
2476: * floating-ambcond:: Ambiguous Conditions
2477: @end menu
2478:
2479:
2480: @c ---------------------------------------------------------------------
2481: @node floating-idef, floating-ambcond, The optional Floating-Point word set, The optional Floating-Point word set
2482: @subsection Implementation Defined Options
2483: @c ---------------------------------------------------------------------
2484:
2485: @table @i
2486:
2487: @item format and range of floating point numbers:
2488: System-dependent; the @code{double} type of C.
2489:
2490: @item results of @code{REPRESENT} when @var{float} is out of range:
2491: System dependent; @code{REPRESENT} is implemented using the C library
2492: function @code{ecvt()} and inherits its behaviour in this respect.
2493:
2494: @item rounding or truncation of floating-point numbers:
2495: What's the question?!!
2496:
2497: @item size of floating-point stack:
2498: @code{s" FLOATING-STACK" environment? drop .}. Can be changed at startup
2499: with the command-line option @code{-f}.
2500:
2501: @item width of floating-point stack:
2502: @code{1 floats}.
2503:
2504: @end table
2505:
2506:
2507: @c ---------------------------------------------------------------------
2508: @node floating-ambcond, , floating-idef, The optional Floating-Point word set
2509: @subsection Ambiguous conditions
2510: @c ---------------------------------------------------------------------
2511:
2512: @table @i
2513:
2514: @item @code{df@@} or @code{df!} used with an address that is not double-float aligned:
2515: System-dependent. Typically results in an alignment fault like other
2516: alignment violations.
2517:
2518: @item @code{f@@} or @code{f!} used with an address that is not float aligned:
2519: System-dependent. Typically results in an alignment fault like other
2520: alignment violations.
2521:
2522: @item Floating-point result out of range:
2523: System-dependent. Can result in a @code{-55 THROW} (Floating-point
2524: unidentified fault), or can produce a special value representing, e.g.,
2525: Infinity.
2526:
2527: @item @code{sf@@} or @code{sf!} used with an address that is not single-float aligned:
2528: System-dependent. Typically results in an alignment fault like other
2529: alignment violations.
2530:
2531: @item BASE is not decimal (@code{REPRESENT}, @code{F.}, @code{FE.}, @code{FS.}):
2532: The floating-point number is converted into decimal nonetheless.
2533:
2534: @item Both arguments are equal to zero (@code{FATAN2}):
2535: System-dependent. @code{FATAN2} is implemented using the C library
2536: function @code{atan2()}.
2537:
2538: @item Using ftan on an argument @var{r1} where cos(@var{r1}) is zero:
2539: System-dependent. Anyway, typically the cos of @var{r1} will not be zero
2540: because of small errors and the tan will be a very large (or very small)
2541: but finite number.
2542:
2543: @item @var{d} cannot be presented precisely as a float in @code{D>F}:
2544: The result is rounded to the nearest float.
2545:
2546: @item dividing by zero:
2547: @code{-55 throw} (Floating-point unidentified fault)
2548:
2549: @item exponent too big for conversion (@code{DF!}, @code{DF@@}, @code{SF!}, @code{SF@@}):
2550: System dependent. On IEEE-FP based systems the number is converted into
2551: an infinity.
2552:
2553: @item @var{float}<1 (@code{facosh}):
2554: @code{-55 throw} (Floating-point unidentified fault)
2555:
2556: @item @var{float}=<-1 (@code{flnp1}):
2557: @code{-55 throw} (Floating-point unidentified fault). On IEEE-FP systems
2558: negative infinity is typically produced for @var{float}=-1.
2559:
2560: @item @var{float}=<0 (@code{fln}, @code{flog}):
2561: @code{-55 throw} (Floating-point unidentified fault). On IEEE-FP systems
2562: negative infinity is typically produced for @var{float}=0.
2563:
2564: @item @var{float}<0 (@code{fasinh}, @code{fsqrt}):
2565: @code{-55 throw} (Floating-point unidentified fault). @code{fasinh}
2566: produces values for these inputs on my Linux box (Bug in the C library?)
2567:
2568: @item |@var{float}|>1 (@code{facos}, @code{fasin}, @code{fatanh}):
2569: @code{-55 throw} (Floating-point unidentified fault).
2570:
2571: @item integer part of float cannot be represented by @var{d} in @code{f>d}:
2572: @code{-55 throw} (Floating-point unidentified fault).
2573:
2574: @item string larger than pictured numeric output area (@code{f.}, @code{fe.}, @code{fs.}):
2575: This does not happen.
2576: @end table
2577:
2578:
2579:
2580: @c =====================================================================
2581: @node The optional Locals word set, The optional Memory-Allocation word set, The optional Floating-Point word set, ANS conformance
2582: @section The optional Locals word set
2583: @c =====================================================================
2584:
2585: @menu
2586: * locals-idef:: Implementation Defined Options
2587: * locals-ambcond:: Ambiguous Conditions
2588: @end menu
2589:
2590:
2591: @c ---------------------------------------------------------------------
2592: @node locals-idef, locals-ambcond, The optional Locals word set, The optional Locals word set
2593: @subsection Implementation Defined Options
2594: @c ---------------------------------------------------------------------
2595:
2596: @table @i
2597:
2598: @item maximum number of locals in a definition:
2599: @code{s" #locals" environment? drop .}. Currently 15. This is a lower
2600: bound, e.g., on a 32-bit machine there can be 41 locals of up to 8
2601: characters. The number of locals in a definition is bounded by the size
2602: of locals-buffer, which contains the names of the locals.
2603:
2604: @end table
2605:
2606:
2607: @c ---------------------------------------------------------------------
2608: @node locals-ambcond, , locals-idef, The optional Locals word set
2609: @subsection Ambiguous conditions
2610: @c ---------------------------------------------------------------------
2611:
2612: @table @i
2613:
2614: @item executing a named local in interpretation state:
2615: @code{-14 throw} (Interpreting a compile-only word).
2616:
2617: @item @var{name} not defined by @code{VALUE} or @code{(LOCAL)} (@code{TO}):
2618: @code{-32 throw} (Invalid name argument)
2619:
2620: @end table
2621:
2622:
2623: @c =====================================================================
2624: @node The optional Memory-Allocation word set, The optional Programming-Tools word set, The optional Locals word set, ANS conformance
2625: @section The optional Memory-Allocation word set
2626: @c =====================================================================
2627:
2628: @menu
2629: * memory-idef:: Implementation Defined Options
2630: @end menu
2631:
2632:
2633: @c ---------------------------------------------------------------------
2634: @node memory-idef, , The optional Memory-Allocation word set, The optional Memory-Allocation word set
2635: @subsection Implementation Defined Options
2636: @c ---------------------------------------------------------------------
2637:
2638: @table @i
2639:
2640: @item values and meaning of @var{ior}:
2641: The @var{ior}s returned by the file and memory allocation words are
2642: intended as throw codes. They typically are in the range
2643: -512@minus{}-2047 of OS errors. The mapping from OS error numbers to
2644: @var{ior}s is -512@minus{}@var{errno}.
2645:
2646: @end table
2647:
2648: @c =====================================================================
2649: @node The optional Programming-Tools word set, The optional Search-Order word set, The optional Memory-Allocation word set, ANS conformance
2650: @section The optional Programming-Tools word set
2651: @c =====================================================================
2652:
2653: @menu
2654: * programming-idef:: Implementation Defined Options
2655: * programming-ambcond:: Ambiguous Conditions
2656: @end menu
2657:
2658:
2659: @c ---------------------------------------------------------------------
2660: @node programming-idef, programming-ambcond, The optional Programming-Tools word set, The optional Programming-Tools word set
2661: @subsection Implementation Defined Options
2662: @c ---------------------------------------------------------------------
2663:
2664: @table @i
2665:
2666: @item ending sequence for input following @code{;code} and @code{code}:
2667: Not implemented (yet).
2668:
2669: @item manner of processing input following @code{;code} and @code{code}:
2670: Not implemented (yet).
2671:
2672: @item search order capability for @code{EDITOR} and @code{ASSEMBLER}:
2673: Not implemented (yet). If they were implemented, they would use the
2674: search order wordset.
2675:
2676: @item source and format of display by @code{SEE}:
2677: The source for @code{see} is the intermediate code used by the inner
2678: interpreter. The current @code{see} tries to output Forth source code
2679: as well as possible.
2680:
2681: @end table
2682:
2683: @c ---------------------------------------------------------------------
2684: @node programming-ambcond, , programming-idef, The optional Programming-Tools word set
2685: @subsection Ambiguous conditions
2686: @c ---------------------------------------------------------------------
2687:
2688: @table @i
2689:
2690: @item deleting the compilation wordlist (@code{FORGET}):
2691: Not implemented (yet).
2692:
2693: @item fewer than @var{u}+1 items on the control flow stack (@code{CS-PICK}, @code{CS-ROLL}):
2694: This typically results in an @code{abort"} with a descriptive error
2695: message (may change into a @code{-22 throw} (Control structure mismatch)
2696: in the future). You may also get a memory access error. If you are
2697: unlucky, this ambiguous condition is not caught.
2698:
2699: @item @var{name} can't be found (@code{forget}):
2700: Not implemented (yet).
2701:
2702: @item @var{name} not defined via @code{CREATE}:
2703: @code{;code} is not implemented (yet). If it were, it would behave like
2704: @code{DOES>} in this respect, i.e., change the execution semantics of
2705: the last defined word no matter how it was defined.
2706:
2707: @item @code{POSTPONE} applied to @code{[IF]}:
2708: After defining @code{: X POSTPONE [IF] ; IMMEDIATE}. @code{X} is
2709: equivalent to @code{[IF]}.
2710:
2711: @item reaching the end of the input source before matching @code{[ELSE]} or @code{[THEN]}:
2712: Continue in the same state of conditional compilation in the next outer
2713: input source. Currently there is no warning to the user about this.
2714:
2715: @item removing a needed definition (@code{FORGET}):
2716: Not implemented (yet).
2717:
2718: @end table
2719:
2720:
2721: @c =====================================================================
2722: @node The optional Search-Order word set, , The optional Programming-Tools word set, ANS conformance
2723: @section The optional Search-Order word set
2724: @c =====================================================================
2725:
2726: @menu
2727: * search-idef:: Implementation Defined Options
2728: * search-ambcond:: Ambiguous Conditions
2729: @end menu
2730:
2731:
2732: @c ---------------------------------------------------------------------
2733: @node search-idef, search-ambcond, The optional Search-Order word set, The optional Search-Order word set
2734: @subsection Implementation Defined Options
2735: @c ---------------------------------------------------------------------
2736:
2737: @table @i
2738:
2739: @item maximum number of word lists in search order:
2740: @code{s" wordlists" environment? drop .}. Currently 16.
2741:
2742: @item minimum search order:
2743: @code{root root}.
2744:
2745: @end table
2746:
2747: @c ---------------------------------------------------------------------
2748: @node search-ambcond, , search-idef, The optional Search-Order word set
2749: @subsection Ambiguous conditions
2750: @c ---------------------------------------------------------------------
2751:
2752: @table @i
2753:
2754: @item changing the compilation wordlist (during compilation):
2755: The definition is put into the wordlist that is the compilation wordlist
2756: when @code{REVEAL} is executed (by @code{;}, @code{DOES>},
2757: @code{RECURSIVE}, etc.).
2758:
2759: @item search order empty (@code{previous}):
2760: @code{abort" Vocstack empty"}.
2761:
2762: @item too many word lists in search order (@code{also}):
2763: @code{abort" Vocstack full"}.
2764:
2765: @end table
2766:
2767:
2768: @node Model, Emacs and Gforth, ANS conformance, Top
2769: @chapter Model
2770:
2771: @node Emacs and Gforth, Internals, Model, Top
2772: @chapter Emacs and Gforth
2773:
2774: Gforth comes with @file{gforth.el}, an improved version of
2775: @file{forth.el} by Goran Rydqvist (icluded in the TILE package). The
2776: improvements are a better (but still not perfect) handling of
2777: indentation. I have also added comment paragraph filling (@kbd{M-q}),
2778: commenting (@kbd{C-x \}) and uncommenting (@kbd{C-u C-x \}) regions and
2779: removing debugging tracers (@kbd{C-x ~}, @pxref{Debugging}). I left the
2780: stuff I do not use alone, even though some of it only makes sense for
2781: TILE. To get a description of these features, enter Forth mode and type
2782: @kbd{C-h m}.
2783:
2784: In addition, Gforth supports Emacs quite well: The source code locations
2785: given in error messages, debugging output (from @code{~~}) and failed
2786: assertion messages are in the right format for Emacs' compilation mode
2787: (@pxref{Compilation, , Running Compilations under Emacs, emacs, Emacs
2788: Manual}) so the source location corresponding to an error or other
2789: message is only a few keystrokes away (@kbd{C-x `} for the next error,
2790: @kbd{C-c C-c} for the error under the cursor).
2791:
2792: Also, if you @code{include} @file{etags.fs}, a new @file{TAGS} file
2793: (@pxref{Tags, , Tags Tables, emacs, Emacs Manual}) will be produced that
2794: contains the definitions of all words defined afterwards. You can then
2795: find the source for a word using @kbd{M-.}. Note that emacs can use
2796: several tags files at the same time (e.g., one for the Gforth sources
2797: and one for your program).
2798:
2799: To get all these benefits, add the following lines to your @file{.emacs}
2800: file:
2801:
2802: @example
2803: (autoload 'forth-mode "gforth.el")
2804: (setq auto-mode-alist (cons '("\\.fs\\'" . forth-mode) auto-mode-alist))
2805: @end example
2806:
2807: @node Internals, Bugs, Emacs and Gforth, Top
2808: @chapter Internals
2809:
2810: Reading this section is not necessary for programming with Gforth. It
2811: should be helpful for finding your way in the Gforth sources.
2812:
2813: @menu
2814: * Portability::
2815: * Threading::
2816: * Primitives::
2817: * System Architecture::
2818: * Performance::
2819: @end menu
2820:
2821: @node Portability, Threading, Internals, Internals
2822: @section Portability
2823:
2824: One of the main goals of the effort is availability across a wide range
2825: of personal machines. fig-Forth, and, to a lesser extent, F83, achieved
2826: this goal by manually coding the engine in assembly language for several
2827: then-popular processors. This approach is very labor-intensive and the
2828: results are short-lived due to progress in computer architecture.
2829:
2830: Others have avoided this problem by coding in C, e.g., Mitch Bradley
2831: (cforth), Mikael Patel (TILE) and Dirk Zoller (pfe). This approach is
2832: particularly popular for UNIX-based Forths due to the large variety of
2833: architectures of UNIX machines. Unfortunately an implementation in C
2834: does not mix well with the goals of efficiency and with using
2835: traditional techniques: Indirect or direct threading cannot be expressed
2836: in C, and switch threading, the fastest technique available in C, is
2837: significantly slower. Another problem with C is that it's very
2838: cumbersome to express double integer arithmetic.
2839:
2840: Fortunately, there is a portable language that does not have these
2841: limitations: GNU C, the version of C processed by the GNU C compiler
2842: (@pxref{C Extensions, , Extensions to the C Language Family, gcc.info,
2843: GNU C Manual}). Its labels as values feature (@pxref{Labels as Values, ,
2844: Labels as Values, gcc.info, GNU C Manual}) makes direct and indirect
2845: threading possible, its @code{long long} type (@pxref{Long Long, ,
2846: Double-Word Integers, gcc.info, GNU C Manual}) corresponds to Forths
2847: double numbers. GNU C is available for free on all important (and many
2848: unimportant) UNIX machines, VMS, 80386s running MS-DOS, the Amiga, and
2849: the Atari ST, so a Forth written in GNU C can run on all these
2850: machines.
2851:
2852: Writing in a portable language has the reputation of producing code that
2853: is slower than assembly. For our Forth engine we repeatedly looked at
2854: the code produced by the compiler and eliminated most compiler-induced
2855: inefficiencies by appropriate changes in the source-code.
2856:
2857: However, register allocation cannot be portably influenced by the
2858: programmer, leading to some inefficiencies on register-starved
2859: machines. We use explicit register declarations (@pxref{Explicit Reg
2860: Vars, , Variables in Specified Registers, gcc.info, GNU C Manual}) to
2861: improve the speed on some machines. They are turned on by using the
2862: @code{gcc} switch @code{-DFORCE_REG}. Unfortunately, this feature not
2863: only depends on the machine, but also on the compiler version: On some
2864: machines some compiler versions produce incorrect code when certain
2865: explicit register declarations are used. So by default
2866: @code{-DFORCE_REG} is not used.
2867:
2868: @node Threading, Primitives, Portability, Internals
2869: @section Threading
2870:
2871: GNU C's labels as values extension (available since @code{gcc-2.0},
2872: @pxref{Labels as Values, , Labels as Values, gcc.info, GNU C Manual})
2873: makes it possible to take the address of @var{label} by writing
2874: @code{&&@var{label}}. This address can then be used in a statement like
2875: @code{goto *@var{address}}. I.e., @code{goto *&&x} is the same as
2876: @code{goto x}.
2877:
2878: With this feature an indirect threaded NEXT looks like:
2879: @example
2880: cfa = *ip++;
2881: ca = *cfa;
2882: goto *ca;
2883: @end example
2884: For those unfamiliar with the names: @code{ip} is the Forth instruction
2885: pointer; the @code{cfa} (code-field address) corresponds to ANS Forths
2886: execution token and points to the code field of the next word to be
2887: executed; The @code{ca} (code address) fetched from there points to some
2888: executable code, e.g., a primitive or the colon definition handler
2889: @code{docol}.
2890:
2891: Direct threading is even simpler:
2892: @example
2893: ca = *ip++;
2894: goto *ca;
2895: @end example
2896:
2897: Of course we have packaged the whole thing neatly in macros called
2898: @code{NEXT} and @code{NEXT1} (the part of NEXT after fetching the cfa).
2899:
2900: @menu
2901: * Scheduling::
2902: * Direct or Indirect Threaded?::
2903: * DOES>::
2904: @end menu
2905:
2906: @node Scheduling, Direct or Indirect Threaded?, Threading, Threading
2907: @subsection Scheduling
2908:
2909: There is a little complication: Pipelined and superscalar processors,
2910: i.e., RISC and some modern CISC machines can process independent
2911: instructions while waiting for the results of an instruction. The
2912: compiler usually reorders (schedules) the instructions in a way that
2913: achieves good usage of these delay slots. However, on our first tries
2914: the compiler did not do well on scheduling primitives. E.g., for
2915: @code{+} implemented as
2916: @example
2917: n=sp[0]+sp[1];
2918: sp++;
2919: sp[0]=n;
2920: NEXT;
2921: @end example
2922: the NEXT comes strictly after the other code, i.e., there is nearly no
2923: scheduling. After a little thought the problem becomes clear: The
2924: compiler cannot know that sp and ip point to different addresses (and
2925: the version of @code{gcc} we used would not know it even if it was
2926: possible), so it could not move the load of the cfa above the store to
2927: the TOS. Indeed the pointers could be the same, if code on or very near
2928: the top of stack were executed. In the interest of speed we chose to
2929: forbid this probably unused ``feature'' and helped the compiler in
2930: scheduling: NEXT is divided into the loading part (@code{NEXT_P1}) and
2931: the goto part (@code{NEXT_P2}). @code{+} now looks like:
2932: @example
2933: n=sp[0]+sp[1];
2934: sp++;
2935: NEXT_P1;
2936: sp[0]=n;
2937: NEXT_P2;
2938: @end example
2939: This can be scheduled optimally by the compiler.
2940:
2941: This division can be turned off with the switch @code{-DCISC_NEXT}. This
2942: switch is on by default on machines that do not profit from scheduling
2943: (e.g., the 80386), in order to preserve registers.
2944:
2945: @node Direct or Indirect Threaded?, DOES>, Scheduling, Threading
2946: @subsection Direct or Indirect Threaded?
2947:
2948: Both! After packaging the nasty details in macro definitions we
2949: realized that we could switch between direct and indirect threading by
2950: simply setting a compilation flag (@code{-DDIRECT_THREADED}) and
2951: defining a few machine-specific macros for the direct-threading case.
2952: On the Forth level we also offer access words that hide the
2953: differences between the threading methods (@pxref{Threading Words}).
2954:
2955: Indirect threading is implemented completely
2956: machine-independently. Direct threading needs routines for creating
2957: jumps to the executable code (e.g. to docol or dodoes). These routines
2958: are inherently machine-dependent, but they do not amount to many source
2959: lines. I.e., even porting direct threading to a new machine is a small
2960: effort.
2961:
2962: @node DOES>, , Direct or Indirect Threaded?, Threading
2963: @subsection DOES>
2964: One of the most complex parts of a Forth engine is @code{dodoes}, i.e.,
2965: the chunk of code executed by every word defined by a
2966: @code{CREATE}...@code{DOES>} pair. The main problem here is: How to find
2967: the Forth code to be executed, i.e. the code after the @code{DOES>} (the
2968: DOES-code)? There are two solutions:
2969:
2970: In fig-Forth the code field points directly to the dodoes and the
2971: DOES-code address is stored in the cell after the code address
2972: (i.e. at cfa cell+). It may seem that this solution is illegal in the
2973: Forth-79 and all later standards, because in fig-Forth this address
2974: lies in the body (which is illegal in these standards). However, by
2975: making the code field larger for all words this solution becomes legal
2976: again. We use this approach for the indirect threaded version. Leaving
2977: a cell unused in most words is a bit wasteful, but on the machines we
2978: are targetting this is hardly a problem. The other reason for having a
2979: code field size of two cells is to avoid having different image files
2980: for direct and indirect threaded systems (@pxref{System Architecture}).
2981:
2982: The other approach is that the code field points or jumps to the cell
2983: after @code{DOES}. In this variant there is a jump to @code{dodoes} at
2984: this address. @code{dodoes} can then get the DOES-code address by
2985: computing the code address, i.e., the address of the jump to dodoes,
2986: and add the length of that jump field. A variant of this is to have a
2987: call to @code{dodoes} after the @code{DOES>}; then the return address
2988: (which can be found in the return register on RISCs) is the DOES-code
2989: address. Since the two cells available in the code field are usually
2990: used up by the jump to the code address in direct threading, we use
2991: this approach for direct threading. We did not want to add another
2992: cell to the code field.
2993:
2994: @node Primitives, System Architecture, Threading, Internals
2995: @section Primitives
2996:
2997: @menu
2998: * Automatic Generation::
2999: * TOS Optimization::
3000: * Produced code::
3001: @end menu
3002:
3003: @node Automatic Generation, TOS Optimization, Primitives, Primitives
3004: @subsection Automatic Generation
3005:
3006: Since the primitives are implemented in a portable language, there is no
3007: longer any need to minimize the number of primitives. On the contrary,
3008: having many primitives is an advantage: speed. In order to reduce the
3009: number of errors in primitives and to make programming them easier, we
3010: provide a tool, the primitive generator (@file{prims2x.fs}), that
3011: automatically generates most (and sometimes all) of the C code for a
3012: primitive from the stack effect notation. The source for a primitive
3013: has the following form:
3014:
3015: @format
3016: @var{Forth-name} @var{stack-effect} @var{category} [@var{pronounc.}]
3017: [@code{""}@var{glossary entry}@code{""}]
3018: @var{C code}
3019: [@code{:}
3020: @var{Forth code}]
3021: @end format
3022:
3023: The items in brackets are optional. The category and glossary fields
3024: are there for generating the documentation, the Forth code is there
3025: for manual implementations on machines without GNU C. E.g., the source
3026: for the primitive @code{+} is:
3027: @example
3028: + n1 n2 -- n core plus
3029: n = n1+n2;
3030: @end example
3031:
3032: This looks like a specification, but in fact @code{n = n1+n2} is C
3033: code. Our primitive generation tool extracts a lot of information from
3034: the stack effect notations@footnote{We use a one-stack notation, even
3035: though we have separate data and floating-point stacks; The separate
3036: notation can be generated easily from the unified notation.}: The number
3037: of items popped from and pushed on the stack, their type, and by what
3038: name they are referred to in the C code. It then generates a C code
3039: prelude and postlude for each primitive. The final C code for @code{+}
3040: looks like this:
3041:
3042: @example
3043: I_plus: /* + ( n1 n2 -- n ) */ /* label, stack effect */
3044: /* */ /* documentation */
3045: @{
3046: DEF_CA /* definition of variable ca (indirect threading) */
3047: Cell n1; /* definitions of variables */
3048: Cell n2;
3049: Cell n;
3050: n1 = (Cell) sp[1]; /* input */
3051: n2 = (Cell) TOS;
3052: sp += 1; /* stack adjustment */
3053: NAME("+") /* debugging output (with -DDEBUG) */
3054: @{
3055: n = n1+n2; /* C code taken from the source */
3056: @}
3057: NEXT_P1; /* NEXT part 1 */
3058: TOS = (Cell)n; /* output */
3059: NEXT_P2; /* NEXT part 2 */
3060: @}
3061: @end example
3062:
3063: This looks long and inefficient, but the GNU C compiler optimizes quite
3064: well and produces optimal code for @code{+} on, e.g., the R3000 and the
3065: HP RISC machines: Defining the @code{n}s does not produce any code, and
3066: using them as intermediate storage also adds no cost.
3067:
3068: There are also other optimizations, that are not illustrated by this
3069: example: Assignments between simple variables are usually for free (copy
3070: propagation). If one of the stack items is not used by the primitive
3071: (e.g. in @code{drop}), the compiler eliminates the load from the stack
3072: (dead code elimination). On the other hand, there are some things that
3073: the compiler does not do, therefore they are performed by
3074: @file{prims2x.fs}: The compiler does not optimize code away that stores
3075: a stack item to the place where it just came from (e.g., @code{over}).
3076:
3077: While programming a primitive is usually easy, there are a few cases
3078: where the programmer has to take the actions of the generator into
3079: account, most notably @code{?dup}, but also words that do not (always)
3080: fall through to NEXT.
3081:
3082: @node TOS Optimization, Produced code, Automatic Generation, Primitives
3083: @subsection TOS Optimization
3084:
3085: An important optimization for stack machine emulators, e.g., Forth
3086: engines, is keeping one or more of the top stack items in
3087: registers. If a word has the stack effect @var{in1}...@var{inx} @code{--}
3088: @var{out1}...@var{outy}, keeping the top @var{n} items in registers
3089: @itemize
3090: @item
3091: is better than keeping @var{n-1} items, if @var{x>=n} and @var{y>=n},
3092: due to fewer loads from and stores to the stack.
3093: @item is slower than keeping @var{n-1} items, if @var{x<>y} and @var{x<n} and
3094: @var{y<n}, due to additional moves between registers.
3095: @end itemize
3096:
3097: In particular, keeping one item in a register is never a disadvantage,
3098: if there are enough registers. Keeping two items in registers is a
3099: disadvantage for frequent words like @code{?branch}, constants,
3100: variables, literals and @code{i}. Therefore our generator only produces
3101: code that keeps zero or one items in registers. The generated C code
3102: covers both cases; the selection between these alternatives is made at
3103: C-compile time using the switch @code{-DUSE_TOS}. @code{TOS} in the C
3104: code for @code{+} is just a simple variable name in the one-item case,
3105: otherwise it is a macro that expands into @code{sp[0]}. Note that the
3106: GNU C compiler tries to keep simple variables like @code{TOS} in
3107: registers, and it usually succeeds, if there are enough registers.
3108:
3109: The primitive generator performs the TOS optimization for the
3110: floating-point stack, too (@code{-DUSE_FTOS}). For floating-point
3111: operations the benefit of this optimization is even larger:
3112: floating-point operations take quite long on most processors, but can be
3113: performed in parallel with other operations as long as their results are
3114: not used. If the FP-TOS is kept in a register, this works. If
3115: it is kept on the stack, i.e., in memory, the store into memory has to
3116: wait for the result of the floating-point operation, lengthening the
3117: execution time of the primitive considerably.
3118:
3119: The TOS optimization makes the automatic generation of primitives a
3120: bit more complicated. Just replacing all occurrences of @code{sp[0]} by
3121: @code{TOS} is not sufficient. There are some special cases to
3122: consider:
3123: @itemize
3124: @item In the case of @code{dup ( w -- w w )} the generator must not
3125: eliminate the store to the original location of the item on the stack,
3126: if the TOS optimization is turned on.
3127: @item Primitives with stack effects of the form @code{--}
3128: @var{out1}...@var{outy} must store the TOS to the stack at the start.
3129: Likewise, primitives with the stack effect @var{in1}...@var{inx} @code{--}
3130: must load the TOS from the stack at the end. But for the null stack
3131: effect @code{--} no stores or loads should be generated.
3132: @end itemize
3133:
3134: @node Produced code, , TOS Optimization, Primitives
3135: @subsection Produced code
3136:
3137: To see what assembly code is produced for the primitives on your machine
3138: with your compiler and your flag settings, type @code{make engine.s} and
3139: look at the resulting file @file{engine.s}.
3140:
3141: @node System Architecture, Performance, Primitives, Internals
3142: @section System Architecture
3143:
3144: Our Forth system consists not only of primitives, but also of
3145: definitions written in Forth. Since the Forth compiler itself belongs
3146: to those definitions, it is not possible to start the system with the
3147: primitives and the Forth source alone. Therefore we provide the Forth
3148: code as an image file in nearly executable form. At the start of the
3149: system a C routine loads the image file into memory, sets up the
3150: memory (stacks etc.) according to information in the image file, and
3151: starts executing Forth code.
3152:
3153: The image file format is a compromise between the goals of making it
3154: easy to generate image files and making them portable. The easiest way
3155: to generate an image file is to just generate a memory dump. However,
3156: this kind of image file cannot be used on a different machine, or on
3157: the next version of the engine on the same machine, it even might not
3158: work with the same engine compiled by a different version of the C
3159: compiler. We would like to have as few versions of the image file as
3160: possible, because we do not want to distribute many versions of the
3161: same image file, and to make it easy for the users to use their image
3162: files on many machines. We currently need to create a different image
3163: file for machines with different cell sizes and different byte order
3164: (little- or big-endian)@footnote{We are considering adding information to the
3165: image file that enables the loader to change the byte order.}.
3166:
3167: Forth code that is going to end up in a portable image file has to
3168: comply to some restrictions: addresses have to be stored in memory with
3169: special words (@code{A!}, @code{A,}, etc.) in order to make the code
3170: relocatable. Cells, floats, etc., have to be stored at the natural
3171: alignment boundaries@footnote{E.g., store floats (8 bytes) at an address
3172: dividable by~8. This happens automatically in our system when you use
3173: the ANS Forth alignment words.}, in order to avoid alignment faults on
3174: machines with stricter alignment. The image file is produced by a
3175: metacompiler (@file{cross.fs}).
3176:
3177: So, unlike the image file of Mitch Bradleys @code{cforth}, our image
3178: file is not directly executable, but has to undergo some manipulations
3179: during loading. Address relocation is performed at image load-time, not
3180: at run-time. The loader also has to replace tokens standing for
3181: primitive calls with the appropriate code-field addresses (or code
3182: addresses in the case of direct threading).
3183:
3184: @node Performance, , System Architecture, Internals
3185: @section Performance
3186:
3187: On RISCs the Gforth engine is very close to optimal; i.e., it is usually
3188: impossible to write a significantly faster engine.
3189:
3190: On register-starved machines like the 386 architecture processors
3191: improvements are possible, because @code{gcc} does not utilize the
3192: registers as well as a human, even with explicit register declarations;
3193: e.g., Bernd Beuster wrote a Forth system fragment in assembly language
3194: and hand-tuned it for the 486; this system is 1.19 times faster on the
3195: Sieve benchmark on a 486DX2/66 than Gforth compiled with
3196: @code{gcc-2.6.3} with @code{-DFORCE_REG}.
3197:
3198: However, this potential advantage of assembly language implementations
3199: is not necessarily realized in complete Forth systems: We compared
3200: Gforth (compiled with @code{gcc-2.6.3} and @code{-DFORCE_REG}) with
3201: Win32Forth 1.2093 and LMI's NT Forth (Beta, May 1994), two systems
3202: written in assembly, and with two systems written in C: PFE-0.9.11
3203: (compiled with @code{gcc-2.6.3} with the default configuration for
3204: Linux: @code{-O2 -fomit-frame-pointer -DUSE_REGS}) and ThisForth Beta
3205: (compiled with gcc-2.6.3 -O3 -fomit-frame-pointer). We benchmarked
3206: Gforth, PFE and ThisForth on a 486DX2/66 under Linux. Kenneth O'Heskin
3207: kindly provided the results for Win32Forth and NT Forth on a 486DX2/66
3208: with similar memory performance under Windows NT.
3209:
3210: We used four small benchmarks: the ubiquitous Sieve; bubble-sorting and
3211: matrix multiplication come from the Stanford integer benchmarks and have
3212: been translated into Forth by Martin Fraeman; we used the versions
3213: included in the TILE Forth package; and a recursive Fibonacci number
3214: computation for benchmark calling performance. The following table shows
3215: the time taken for the benchmarks scaled by the time taken by Gforth (in
3216: other words, it shows the speedup factor that Gforth achieved over the
3217: other systems).
3218:
3219: @example
3220: relative Win32- NT This-
3221: time Gforth Forth Forth PFE Forth
3222: sieve 1.00 1.30 1.07 1.67 2.98
3223: bubble 1.00 1.30 1.40 1.66
3224: matmul 1.00 1.40 1.29 2.24
3225: fib 1.00 1.44 1.26 1.82 2.82
3226: @end example
3227:
3228: You may find the good performance of Gforth compared with the systems
3229: written in assembly language quite surprising. One important reason for
3230: the disappointing performance of these systems is probably that they are
3231: not written optimally for the 486 (e.g., they use the @code{lods}
3232: instruction). In addition, Win32Forth uses a comfortable, but costly
3233: method for relocating the Forth image: like @code{cforth}, it computes
3234: the actual addresses at run time, resulting in two address computations
3235: per NEXT (@pxref{System Architecture}).
3236:
3237: The speedup of Gforth over PFE and ThisForth can be easily explained
3238: with the self-imposed restriction to standard C (although the measured
3239: implementation of PFE uses a GNU C extension: global register
3240: variables), which makes efficient threading impossible. Moreover,
3241: current C compilers have a hard time optimizing other aspects of the
3242: ThisForth source.
3243:
3244: Note that the performance of Gforth on 386 architecture processors
3245: varies widely with the version of @code{gcc} used. E.g., @code{gcc-2.5.8}
3246: failed to allocate any of the virtual machine registers into real
3247: machine registers by itself and would not work correctly with explicit
3248: register declarations, giving a 1.3 times slower engine (on a 486DX2/66
3249: running the Sieve) than the one measured above.
3250:
3251: @node Bugs, Pedigree, Internals, Top
3252: @chapter Bugs
3253:
3254: Known bugs are described in the file BUGS in the Gforth distribution.
3255:
3256: If you find a bug, please send a bug report to !!. A bug report should
3257: describe the Gforth version used (it is announced at the start of an
3258: interactive Gforth session), the machine and operating system (on Unix
3259: systems you can use @code{uname -a} to produce this information), the
3260: installation options (!! a way to find them out), and a complete list of
3261: changes you (or your installer) have made to the Gforth sources (if
3262: any); it should contain a program (or a sequence of keyboard commands)
3263: that reproduces the bug and a description of what you think constitutes
3264: the buggy behaviour.
3265:
3266: For a thorough guide on reporting bugs read @ref{Bug Reporting, , How
3267: to Report Bugs, gcc.info, GNU C Manual}.
3268:
3269:
3270: @node Pedigree, Word Index, Bugs, Top
3271: @chapter Pedigree
3272:
3273: Gforth descends from BigForth (1993) and fig-Forth. Gforth and PFE (by
3274: Dirk Zoller) will cross-fertilize each other. Of course, a significant part of the design of Gforth was prescribed by ANS Forth.
3275:
3276: Bernd Paysan wrote BigForth, a child of VolksForth.
3277:
3278: VolksForth descends from F83. !! Authors? When?
3279:
3280: Laxen and Perry wrote F83 as a model implementation of the
3281: Forth-83 standard. !! Pedigree? When?
3282:
3283: A team led by Bill Ragsdale implemented fig-Forth on many processors in
3284: 1979. Dean Sanderson and Bill Ragsdale developed the original
3285: implementation of fig-Forth based on microForth.
3286:
3287: !! microForth pedigree
3288:
3289: A part of the information in this section comes from @cite{The Evolution
3290: of Forth} by Elizabeth D. Rather, Donald R. Colburn and Charles
3291: H. Moore, presented at the HOPL-II conference and preprinted in SIGPLAN
3292: Notices 28(3), 1993. You can find more historical and genealogical
3293: information about Forth there.
3294:
3295: @node Word Index, Node Index, Pedigree, Top
3296: @chapter Word Index
3297:
3298: This index is as incomplete as the manual. Each word is listed with
3299: stack effect and wordset.
3300:
3301: @printindex fn
3302:
3303: @node Node Index, , Word Index, Top
3304: @chapter Node Index
3305:
3306: This index is even less complete than the manual.
3307:
3308: @contents
3309: @bye
3310:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>