F.I.G-Forth for i586-pc-Linux/ELF

|                                                                                                        |

<== : [de] : [E4:e] : [L4:e] : [mail]

[Glossary] [Reference]

[numerics]

F.I.G.RU : F.I.G.UK : FORTH e.V. : tutorial

Files ref:
- f4a-(version).tar.bz2, Forth Compiler/Interpreter Source;
- f4a_(version).{dsc,tar.gz} debian F4 source package
  f4a_(version)_i386.deb, debian F4 binaries;
from the F4 sources package:
- change-log;
- glossary from F4 assembler source;
- f4view, screen-files viewing mode for 'less' ("C" version).
- f4x.scr, hi-level extensions;
compiling the following screen-files requires f4x,too:
- f4ans.scr, ANS-4th adaptation;
- f4e.scr, screen Editor for 2 files, requires figed;

F4 FIG-Forth (1.0) , 'traditional', indirectly threaded Forth;
Copyright 2002 Berlin by h-p recktenwald; F4 is experimental software to which no warranty applies and which may unrestrictedly be used to whichever (legal, wrt EU legislation) purpose, provided that this notice and a pointer to the original source (this site) is included.
- "f4a" (change-log) fig-Forth-1.0 type,
  mainly to testing assembly w. AS and CPP which, proved to be a fast and reliable, i.e. a notably better tool than, for instance, the "nasm"; for details to be included w. "lib4th" and, for other experiments like automatic memory de-/allocation or, accessing the linux system calls &c.
  For instance,
  - F4 transparently, on demand allocates any required memory space from the host system, i.e. no need to specifying the expected memory requirements by some, rather obscure additional command line arguments.
    No 'stack overflow' of either stack occurs and, always sufficient dictionary and block-file buffers space available - within bounds of a linux job, i.e. about 1GB for the dictionary, max 3GB over all. The system starts w. one memory 'page' (4K) for each of the F4 distinct memory ranges of terminal input buffer, system and user variables, data-space, dictionary and, the data- and return-stacks. Memory extends as required, at runtime or while compiling.
    dictionary and variable's data memory sizes will also be reduced according to the actual requirements, with an appropriate 'hysteresis'.
  - With the hi-level extension word {save} any F4 program can store itself as an executeable Linux/ELF binary.
  - All fig-standard words implemented and (shortly) tested, extended by
    - basic random file access words,
    - string slicing and text 'escape' sequences conversion (like bash "\(numeric)", "\e" &c),
    - factorial, square root and basic arithmetics, sufficient to evaluating any transcendental functions
    - and, everything else which would make for a fairly easily useable stand-alone, basic Forth system
    re glossary; the "load"-able "words" displays all vocabularies' definitions (f4x.scr).
  - Extendable to (almost) ANS-4th compliance (f4ans.scr).
  - Besides {tick} to reading the CPU clock counter, NO 'benchmark' stuff supplied w. F4 - which I'd consider merely a tremendous waste of time and (inner as well as outer) space.
- Binary about 50K of size. The compiled program is independent of any other software (but the Linux kernel), pre-compiled, stripped binary for i586-pc-Linux/ELF, Linux 2.4.22, in the archive.
- The F4 archive includes a separate program, f4view, w. source based on F4 as well as by an independent "C" variant) which adds a block-file viewing mode to Linux 'less'.
- Recompiling requires the 'cpp' (gcc v2.95.4, 3.1, 3.3) and 'as' (binutils v2.12+) standard Linux programs for software development, plus, the rsp. Linux source header files (linux/include/{asm,linux}) for automatic adaptation to the currently used Linux version; the 'make-f4s' bash (v2.05b) script efficiently substitutes the lame & clumsy group of GNU 'configure' and 'make' &c programs.

[top] : [oben]

Different or extended wrt standard fig-Forth:

F4 is self-contained, independent of any external library, i.e. no 'libc' &c!
and can save itself, at current state, as a Linux/ELF executeable binary (by hi-level words).
Dynamic memory map, allocation w. 'mmap' to the distinct, dictionary, data-, return-stack, user-vari and tib ranges, i.e. all F4 memory ranges independently extend into host memory, at run-time, according to the actual requirements. No garbage-collection provided - the reason to which I'd suggest to simply avoid, by clean program structures...
Safe, write protected kernel memory, w. unmodifiable 'constant's; 'variables' &c refer to writable memory location, pointed to by content of 'pfa' (e.g. {limit}).
Almost all words implemented as 'primitves'.
Data-stack @TOS in cpu register EAX; characters represented by 8-bit bytes, cells by 32-bit dwords.
'little endian' bytes & cells order, datastack 'push' stores towards higher addr. for 'standard' as well as i86-style cpu conformant, consistent data storage. i.e. { dn adr 2! } stores l.s.cell dn at address adr and, { 1 dup >r 2 dup >r 2r> = } returns 'true'.
All Linux kernel system calls available by name, taken from the actually present Linux sources.
Word headers linked by -ve disp to preceding word, data structure modified to coping w. AS/GASP.
{vocabulary} by 'pfa' content referring to writable memory location, pseudo-nfa of standard, extended voc-defn.
Search order @context and @current with follow-up vocabularies assignable to any vocabulary definition, {2nd-voc};
neither, the number of vocabularies nor the chained search order is limited other than by allocatable memory.
{forget} through any search order, stores {forth} if {current} or {context} included; {marker} by hi-level extn.
A specific forget handler can be assigned to any word, for clean-up or other actions to be executed before removal.
{warm} re-start w. SIGQUIT, in a running program by <CTRL"\"> or, triggered externally w. the <kill> command &c, which recovers from accidental, endless loops - I found this working on even the most tight cpu code loops.
SIGALRM can be triggered by {alarm}, for execution of a hi-level deferred signal handler.
Hi-level Forth Debugging facility w. four different modes, single stepping inclusive, which can be used at any system state, while compiling or interpreting, on any words whether defining or executing, transparently w. no different data or code, by re-direction of return to <next>, at run-time.
Supplied defining words include deferred execution {defer} and user-deferred words, 'user'-dataspace alterable constant {ucons}, incrementing {cons+}, alterable {constant} in variables' memory.
By user-vari deferred {abort}, {emit} (capable of multiple bytes chars), {type}, {key}, {?key}, {expect}, {xy}, {at-xy} and 2nd-ary {interpret} handler, immediately after xec of {-find}.
Random file access by {fread}, {fwrite}, {fposre}, {fstat}, {mmapf} &c which, transparently by reference w. the rsp. redirectable i/o-'channels' can be used on files or, their mmap-ed representation in memory.
Loadable file path's finding faclity wrt CWD, F4-home directory, PATH environmental variable, installation 'libdir'.
Optimizing (code compacting) {if}, {until}, {while} after {0=}, {0<}, {0< 0=} and, conversion by {;} to branch into last word if a colon defn, also eliminates tail-recursion. Two consecutive 'literal's compiled as 'dlit', compact { drop exit }, { drop ; } and, { { drop } exit else ... endif } compiled as { { drop } exit endif ... }.
{enter begin .. entry .. 0= until} to eliminating the unconditional branch in {begin .. while .. repeat}; {until} may be used after {while}.
{pick} and {roll} additional, reversed function w. -ve index, +/- {pick} efficiently substitutes 'local' items.
Other additional words conditionally in the kernel for operations on multiple cells items, double, quad, unlimited size.
Unlimited length string handling, {/string}, {skip}, {scan} (and reverse), {e\stg}, {scount}, {zcount}, {s=}, {match}.
iso8859 8-bit character sets, selectable letter case dependency, (yet rudimentary) multiple-bytes characters support.
Terminal control by {max-xy}, {xy}, {tab}, {at-xy} and w. 'bash' style escaped strings by {e\stg};
vectored VT-contol words {xy}, {at-xy}, suitable to and tested in Linux console, "eterm", "rxvt" and KDE-"konsole".
{lload} by word name selective loading from a given or, current/default library screen-file; {include} to loading by file-name, beginning at given screen no.; {using} & other, commonly known words for block-files access.
All {load}ing words are nestable w.o. limits and preserve the current programming context.
Besides block-file considered F4 standard File input, {chain} provided to interpreting from sequential files by the rsp. channel no. parameter, and {end} for early termination; nestable w.o. limits.
Unlimited size 'local' memory de-/allocation which, for instance, enables string manipulation w.o. globally defined buffers and, by numeric index accessible local 'variables' &c (re below)
hi-level extensions - {load}able from f4x.scr - include
- { save' filename' } saves the rsp F4 program as a Linux/ELF executeable (stripped) binary.
- { HELP forthword } displays the rsp. glossary entry or, the defining screen in the rsp. library block-file. An additional word, {hlp!}, extends the list of searched source files by the currently loading one, for display of word definitions from any other source.
- transparent, "local" memory and, cell-sized local variables which allocate no additional memory, at all - the definitions of which require no other prerequisites than access to the user-vari {s0}, thus should easily be 'portable' to any other fig-Forth style system. Basic de-/allocation word for run-time speed by primitive, in kernel; hi-level aequivalent supplied, for reference.
- {evaluate} for source text from string execution, self-containd and 'portable' to any (fig-type) Forth system,
- conditional compiling/loading extensions - basic words in the kernel, hi-level for reference, separately.
- safe(!), positional case: construct which can be compiled into a hi-level word or, defined as a named word.
- string variables w. rsp. string processing words, escaped {e\type} & {e\print}, &c
- F4 specific words also provided as hi-level aequivalent definitions in a separate screen-file.
- The fig-Forth line editor and the twin files' full screen editor which was adapted from the lib4th 'f8ed' implementation, for 'block files' (screen files).
- A floating point numbers package which implements 'real numbers' by pairs of doubles. All fundamental operations provided, square root, logarithmus naturalis and exponentation inclusive, with which any sort of higher order arithmetics could be built, conversion routine to and from the ieee-754 (normalized doubles) format, a real numbers converting input mode, by prefix, &c. Source in screen-file "f4f.scr" and "f4z.scr" (Complex arith). The ranum extension most certainly is not readily 'portable' because, for run-time efficiency many details are specific to F4, which was extended by several multiple-cells arithmetic operations - re file "f4c.scr" (in the archive, only) which, supplies hi-level aequivalents to all non-standard kernel words.
  the f4o.scr collection of some (rather nostalgic) radio communications formulae, is based on the F4 'real numbers' implementation.
- printer control, simultaneous output to console & printer.
ANS-Forth compliance by hi-level extensions from another screen-file (f4ans.scr) which implenments the word-sets
- STRING SEARCH-ORDER TOOLS/-EXT MEMORY-ALLOC FILE/-EXT FACILITY/-EXT DOUBLE/-EXT BLOCK/-EXT CORE/-EXT
- Not implemented:
  - FLOAT because relying on ieee-745 standard requires undue effort for in-adeaquate exactness
    and, because F4 provides the f.p operations by 'real numbers';
  - LOCALS/-EXT because, imo, F4 umlimited size implementation much superior;
  - SEARCH-EXT because F4 chained vocs are, at least, equally versatile.
Simple, external shell command execution, { " command" SH }.
F4 can be used inter-actively as well as w. piped or re-directed i/o, for scripting and "#!" execution.
Program invocation w. unlimited (other than by host) number and length of command-line arguments which initially will be executed and discarded or, left in place after "--" delimiter.

Further information in the asm source file, description of Forth words in glossary, more about the (original) fig-Forth installation and several hi-level Forth programming examples in the archive.