ikysil / ikforth

ikforth is an idiomatic Forth implementation.

ikforth

ikforth is an idiomatic Forth implementation.

A few facts:

• 32 bits code
• Runs on Linux and Windows (tested with Wine)
• Supports Indirect and Direct Threaded Code representations
• Image-based system
• x86 assembler is used to bootstrap image capable of interpreting from files
• Image is NOT relocatable - absolute 32 bits addresses are used in native and threaded code
• CELL size is 32 bits
• CHAR size is 8 bits
• addressable unit - 1 byte (8 bits)

---

• https://forth-standard.org/
• http://www.forth200x.org/

ikforth's Issues

FLOAT: implement format output

\ Compact Formatted String
\ ------- --------- ------
\ FS. FS.R (FS.) Scientific
\ FE. FE.R (FE.) Engineering
\ F. F.R (F.) Fixed-point
\ G. G.R (G.) General

FLOAT: F. output format

Answers between 10^10 and 10^-2 were always displayed as floating-point numbers with the decimal point properly located and the exponent field blank.

Reorganize bootstrap dictionary source code

Reorganize bootstrap dictionary source code.

Main goal: clear separation between CPU architecture-specific code and CPU-neutral threaded code.

Sub-goals:

• keep source files size manageable.

Implement NAME>COMPILE

https://forth-standard.org/standard/tools/NAMEtoCOMPILE

Implement 17.6.2.2141 REPLACES

https://forth-standard.org/standard/string/REPLACES

Implement INTERPRET using RECOGNIZERs

See http://amforth.sourceforge.net/pr/Recognizer-rfc-C.html for reference.

MainProc does not respect stdcall calling convention

This leads to SEGFAULT in PIC code as EBX is used as a GOT (Global Offset Tables) pointer.

All
The 32-bit x86 calling conventions all preserve the EDI, ESI, EBP, and EBX registers, using the EDX:EAX pair for return values.

__stdcall
This is the calling convention used for Win32, with exceptions for variadic functions (which necessarily use _cdecl) and a very few functions that use _fastcall. Parameters are pushed from right to left [corrected 10:18am] and the callee cleans the stack. Function names are decorated by a leading underscore and a trailing @-sign followed by the number of bytes of parameters taken by the function.
3:44 PM
i386
This is a 32-bit platform. The stack grows downwards. Parameters to functions are passed on the stack in reverse order such that the first parameter is the last value pushed to the stack, which will then be the lowest value on the stack. Parameters passed on the stack may be modified by the called function. Functions are called using the call instruction that pushes the address of the next instruction to the stack and jumps to the operand. Functions return to the caller using the ret instruction that pops a value from the stack and jump to it. The stack is 16-byte aligned just before the call instruction is called.

Functions preserve the registers ebx, esi, edi, ebp, and esp; while eax, ecx, edx are scratch registers. The return value is stored in the eax register, or if it is a 64-bit value, then the higher 32-bits go in edx. Functions push ebp such that the caller-return-eip is 4 bytes above it, and set ebp to the address of the saved ebp. This allows iterating through the existing stack frames. This can be eliminated by specifying the -fomit-frame-pointer GCC option.

As a special exception, GCC assumes the stack is not properly aligned and realigns it when entering main or if the attribute ((force_align_arg_pointer)) is set on the function.

float-ieee-binary: F+ and F- "result is not rounded/chopped"

Reorganize loader code

Implement 17.6.2.2255 SUBSTITUTE

https://forth-standard.org/standard/string/SUBSTITUTE

Migrate from OpenWatcom's wasm to flat assembler (fasm)

float-ieee-binary: Review internal representation

Move TRAVERSE-WORDLIST to bootstrap image

TODO: Migrate to Linux/Wine/OpenWatcom/FlatAssembler toolchain

Migrate to Linux/Wine/OpenWatcom/FlatAssembler toolchain

• src/loader
• src/image

$EXIT in assembler source prevents SEE from decompiling whole definitions.

FLOAT: Implement float recognizer

Migrate extended literal implementation to recognizers

Implement MARKER

https://forth-standard.org/standard/core/MARKER

MARKER
( "name" -- )
Skip leading space delimiters. Parse name delimited by a space. Create a definition for name with the execution semantics defined below.

name Execution:
( -- )

Restore all dictionary allocation and search order pointers to the state they had just prior to the definition of name. Remove the definition of name and all subsequent definitions. Restoration of any structures still existing that could refer to deleted definitions or deallocated data space is not necessarily provided. No other contextual information such as numeric base is affected.

Open points:

• restoring values of DEFERs
  • idea - redefine DEFER or IS

float-ieee-binary: +0e <> -0e which contradicts IEEE

Since the sign bit can take on two different values, there are two zeros, +0 and -0. If a distinction were made when comparing +0 and -0, simple tests like if (x = 0) would have very unpredictable behavior, depending on the sign of x. Thus the IEEE standard defines comparison so that +0 = -0, rather than -0 < +0. Although it would be possible always to ignore the sign of zero, the IEEE standard does not do so. When a multiplication or division involves a signed zero, the usual sign rules apply in computing the sign of the answer. Thus 3·(+0) = +0, and +0/-3 = -0. If zero did not have a sign, then the relation 1/(1/x) = x would fail to hold when x = ±. The reason is that 1/- and 1/+ both result in 0, and 1/0 results in +, the sign information having been lost. One way to restore the identity 1/(1/x) = x is to only have one kind of infinity, however that would result in the disastrous consequence of losing the sign of an overflowed quantity.

Another example of the use of signed zero concerns underflow and functions that have a discontinuity at 0, such as log. In IEEE arithmetic, it is natural to define log 0 = - and log x to be a NaN when x < 0. Suppose that x represents a small negative number that has underflowed to zero. Thanks to signed zero, x will be negative, so log can return a NaN. However, if there were no signed zero, the log function could not distinguish an underflowed negative number from 0, and would therefore have to return -. Another example of a function with a discontinuity at zero is the signum function, which returns the sign of a number.

What Every Computer Scientist Should Know About Floating-Point Arithmetic, section Signed Zero

float-ieee-binary: F/ is neither chopped nor correctly rounded.

Migrate LINCON implementation to recognizers

Wrong compilation date and time is captured for Win32 target

A wrong compilation date and time are captured for the Win32 target.

Output on startup:

$ ./IKForth-nt.exe


IKForth 20.NEXT
Unlicense since 1999 by Illya Kysil
Compiled: 1970-01-01 00:01:47

Platform: Win32

float-ieee-binary: Improve accuracy of FLN and FLNP1

0 (10)[I]> 10e-10 fln f.

-1.302989240475641496E1 OK

DISASTER!

Reorganize lincon code

Implement SEARCH-WORDLIST using TRAVERSE-WORDLIST

Improve literal-ext.4th

Ideas:

• determine required BASE from prefix;
• process remaining string once.

High CPU consumption while waiting for user's input in WIN-ACCEPT

Root cause - call to ReadConsoleInput in WIN-CONSOLE-EKEY fails with

ERROR_INVALID_FUNCTION

1 (0x1)

Incorrect function.

Both Cygwin and Git-Bash (MSYS) consoles are affected.

Seems to be working fine in CMD or WSL console window.

float-ieee-binary: implement conversion between internal representation and IEEE binary formats

float-ieee-binary: implement conversion between internal representation and IEEE binary formats.

Required for SF@ SF! DF@ DF! implementation.

Document build process

Implement FLOAT wordset

float-ieee-binary: Square root is neither chopped nor correctly rounded.

Running test of square root(x).
Testing if sqrt(X * X) == X for 20 Integers X.
Test for sqrt monotonicity.
sqrt has passed a test for Monotonicity.
Testing whether sqrt is rounded or chopped.
Square root is neither chopped nor correctly rounded.
Observed errors run from -6.049382720070228842E-1 to 5.000000000000000000E-1  ulps.

float-ieee-binary: IEEE requires -0e FSQRT = -0e

float-ieee-binary: DEFECT while Testing X^((X + 1) / (X - 1)) vs. exp(2) = 7.389056098930650228E0 as X -> 1.

Testing X^((X + 1) / (X - 1)) vs. exp(2) = 7.389056098930650228E0 as X -> 1.                                                        
DEFECT Calculated 7.389056100650514238E0 for                                                                                        
(1 + (-5.421010862427522170E-20 ) ^ (-3.689348814741910323E19 );                                                                    
differs from correct value by 1.719864010756022577E-9                                                                               
This much error may spoil financial                                                                                                 
calculations involving tiny interest rates.  

Implement 15.6.2.2297 TRAVERSE-WORDLIST

https://forth-standard.org/standard/tools/TRAVERSE-WORDLIST

float-ieee-binary: >FLOAT is too slow for large exponents

float-ieee-binary: Number of significant digits reported by paranoia is too low

float-ieee-binary: Number of significant digits reported by paranoia is too low.

Precision cannot be characterized by an Integer number
of significant digits but, by itself, this is a minor flaw.
The number of significant digits of the Radix is 6.92083333333333333

The value in range 60-64 is expected.

float-ieee-binary: REPRESENT is too slow for large exponents

Similar to #39

Current implementation of ?PAIRS breaks CS-PICK and CS-ROLL

https://forth-standard.org/standard/tools/CS-PICK
https://forth-standard.org/standard/tools/CS-ROLL

Idea:

• save value for ?PAIRS in a variable instead of data stack - there is a risk that some broken structures will pass the check

Migrate WINCON implementation to recognizers

Implement NAME>STRING

https://forth-standard.org/standard/tools/NAMEtoSTRING

Implement support for constants dictionary

Implement support for constants dictionary

• no executable code in the definitions
• 1 CELL value
• 1 CELL pointer to additional data
• duplicates are not searchable, only the last definition is returned
• binary search

Improve REC:NUM implementation

Split REC:NUM into separate recognizers for single and double literals.

Double echo of input when running in Cygwin or Git Bash consoles

Double echo of input when running in Cygwin or Git Bash consoles

Output:

0 (10)[I]> .s
.s
 <- TOS             0 cells OK

All input is echoed back when WIN-REDIRECT- input words are used.

See #46 for related changes.

WIN-PAGE does not clear console when executed with wineconsole

WIN-PAGE does not clear console when executed with wineconsole.
The lpNumberOfCharsWritten parameter to FillConsoleOutputCharacter can not be NULL under WINE.

Implement NAME>INTERPRET

https://forth-standard.org/standard/tools/NAMEtoINTERPRET

Migrate LOCALs implementation to recognizers

Build in Cygwin

Hi! How to build ikforth in Cygwin environment?

Running scons from the project root directory produces the key error: KeyError: 'HSYS' in file SConstruct, line 7.

float-ieee-binary: Improve F**

Improve F**:

• add special handling for integer powers

paranoia report:

Testing powers Z^i for small Integers Z and i.
DEFECT computing  -1.000000000000000000E0 ^-3.000000000000000000E0
    yielded 1.000000000000000000E0
    which compared unequal to correct -1.000000000000000000E0
         they differ by 2.000000000000000000E0
Similar discrepancies have occurred 5  times.
DEFECT computing  2.000000000000000000E0 ^1.000000000000000000E0
    yielded 1.999999999999999997E0
    which compared unequal to correct 2.000000000000000000E0
         they differ by -2.168404344971008868E-18
Errors like this may invalidate financial calculations
involving interest rates.
Similar discrepancies have occurred 325  times.
Diagnosis resumes after milestone Number 100

Implement 17.6.2.2375 UNESCAPE

https://forth-standard.org/standard/string/UNESCAPE

float-ieee-binary: INCORRECT RESULT: T{ 1.E 1.00005E tf= -> false }T

INCORRECT RESULT: T{ 1.E 1.00005E tf= -> false }T