• [ANN] Gforth 1.0.1 released

    From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Sun Nov 1 10:01:24 2026
    From Newsgroup: comp.lang.forth

    Tomorrow it will be 18 years since we released Gforth 0.7.0, so it's
    time for a new release. It's also 34 years since we started Gforth in
    the summer of 1992, so it's about time for Gforth 1.0. We have
    released Gforth 1.0.0 on October 25, and have released 1.0.1 with
    mainly portability fixes yesterday.

    # What is Gforth?

    Gforth is a fast and portable implementation of Forth-2012. It works
    nicely with the Emacs editor, offers some nice features such as input completion and history, backtraces, a decompiler and a powerful locals facility, and it has a comprehensive manual. Gforth combines
    traditional threaded-code implementation techniques with native code
    for performance similar to SwiftForth in the engine gforth-fast,
    better debugging in the engine gforth, and support for traditional indirect-threaded code in the engine gforth-itc for programs that
    require that. Gforth is distributed under the GNU General Public
    license (see COPYING).

    # User-visible differences between Gforth 0.7 and 1.0:

    You can find a more detailed version of this section with links to
    related documentation at <https://gforth.org/manual/1.0/NEWS.html>.

    ## Stability

    It is now documented which words are intended to be permanently
    supported, and which are not.

    ## Headline features

    * The text interpreter can recognize more things:
    * Additional ways to write literals in source code: scaled notation
    for FP numbers (6k5, 23%); strings ("string"), xts (`word),
    nts (``word), body addresses (<word>, <word+8>).
    * You can specify the vocabulary (or several) of a word, e.g.,
    `forth:and` vs. `assembler:and`.
    * Nonparsing syntax for dealing with value-flavoured and
    defer-flavoured words (`v` and `d` in the following examples): `->v`
    for `to v`; `+>v` for `+to v`; `'v` for `addr v`; `@>d` for
    `action-of d`; `=>d` for `is d`.
    * Contents of environment variables: `${LANG}`
    * You can extend the text interpreter with more **recognizers**

    * IDE features:
    * Show source code of a word (`locate browse`).
    * show uses of a word (`where nw bw ww`).
    * backtraces show source locations and can be browsed (`nt bt tt`);
    * and use an editor if desired (`edit g gg whereg`)

    * "Smart `.s`: `...` guesses what stack items mean and displays them
    appropriately. `.s` itself stays dumb.

    * A status line at the bottom of the terminal shows `BASE`, stacks,
    and search order.

    * Multi-Tasking on multiple cores or hardware threads.

    Message queues (similar to the actor model) provide a way to combine
    communication with synchronization of the tasks.

    Cilk is useful for distributing work across tasks.

    * C interface enhancements, includig callbacks.

    * The dictionary can now have more than one section, each with its own
    dictionary pointer, which allows allocation without affecting other
    sections, used, e.g., for nested definitions.

    * Postpone multiple words with `]]`...`[[`.

    * Value-flavoured and defer-flavoured fields.

    * Per-task values and defers.

    * Closures: Execution tokens for code with data.

    * New word header layout, and based on that:
    * Modify the behaviour of words: `set-does> set-compsem set->int
    set->comp set-name>string set-name>link`; using a code address
    instead of an xt: `set-execute`; new code addresses for that:
    `dovalue: dodoes: doabicode:`
    * User-defined `to` etc.: `to-table: n/a to-class: >uvalue set-to`
    * Modify the implementation of words: `set-optimizer`
    * For fans of non-postfix syntax: `compsem: intsem: opt:`
    * Creating a word from a template: `create-from reveal reveal!
    noname-from`
    * Apply `set-does>` etc. to a word defined earlier: `make-latest`
    * Introspection: `.hm immediate?`

    * Performance comparable to SwiftForth
    * IP-update optimization speeds up loop-dominated programs by a factor of 2
    * Literal stack allows constant folding and other optimizations

    ## No longer documented words

    Many of these words are still in Gforth 1.0, but they may be removed
    in the future.

    * `.name` (use `id.`);
    * `does-handler!` (implementation changed, use `set-does>`);
    * `/does-handler` (implementation changed);
    * `@local# f@local# laddr# lp+!#` (replaced by `@localn f@localn lp+n lp+!`);
    * `clear-libs` (interface changed, use `c-library` ... `end-c-library`)
    * `<interpretation interpretation> <compilation compilation>
    create-interpret/compile` (replaced by `set->int set-compsem`)
    * `naligned` (use `*aligned`)
    * `name>comp name>int` (use `name>compile name>interpret`)
    * `path-allot` (use `dup , 0 , allot`)
    * `sl@ sw@ ul@ uw@` (use `l@ l>s`; `w@ w>s`; `l@`; `w@`).
    * Internal and therefore no longer documented: `;s block-position
    cfalign cfaligned compile-lp+! empty-buffer name?int s>number?
    s>unumber? save-buffer`

    ## Other additional features

    We added many other words, see
    <https://gforth.org/manual/1.0/NEWS.html>


    # Where to get it and online resources

    You can download Gforth 1.0.1 from

    https://www.complang.tuwien.ac.at/forth/gforth/gforth-1.0.1.tar.xz

    and find other files and information at

    https://www.complang.tuwien.ac.at/forth/gforth/

    You can also find information at

    https://gforth.org/

    in particular the documentation:

    https://gforth.org/manual/1.0/

    Eventually the tarball will also appear on
    https://ftp.gnu.org/gnu/gforth/ and its mirrors, and binary
    distributions for various systems (Debian, OpenSuse, Flatpak, Snap,
    Docker, brew).

    In particular, gforth-1.0.0 for AMD64 and ARM64 already exists on
    Docker, and you can run it with

    docker run -it --rm forthy42/gforth gforth

    (or use gforth-fast or gforth-itc instead of the last "gforth").

    However, currently there is only the tag "latest" for gforth images on hub.docker.com, so when Bernd Paysan (forthy42) puts the next snapshot
    on hub.docker.com, you will get an upgrade to that. I hope he will
    add a tag for 1.0 or 1.0.1, and then the command above should look
    like

    docker run -it --rm forthy42/gforth:1.0 gforth

    Our recommendation for running Gforth 1.0 on Windows is to run it on
    WSL (use an appropriate Gforth package for Linux for that).

    Alternatively, you can use a Docker image of Gforth on Windows.

    For Android, Bernd Paysan releases Gforth as an app, but its
    usefulness is more and more limited by Android security policies, so
    it may be better to install the termux app and install gforth there
    (either from source or with the Debian package once it is available).

    ## Development version

    If you are interested in development versions, the tarballs of
    snapshots are published on

    https://www.complang.tuwien.ac.at/forth/gforth/Snapshots/

    and the latest snapshot is always at

    https://www.complang.tuwien.ac.at/forth/gforth/Snapshots/current/gforth.tar.xz

    If you want to be even more bleeding edge, you can get the git from
    Savannah, see

    https://savannah.gnu.org/git/?group=gforth

    In particular you can get the latest version of the master branch
    without history with

    git clone --depth 1 https://git.savannah.gnu.org/git/gforth.git

    and if you want the commit history, too, you leave the "--depth 1"
    away.

    Savannah seems to be a bit overloaded lately, however. You can also
    get the latest git head by cloning from the mirrors on gitlab or
    github:

    git clone --depth 1 https://gitlab.com/forthy42/gforth.git
    git clone --depth 1 https://github.com/forthy42/gforth.git

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Paul Rubin@no.email@nospam.invalid to comp.lang.forth on Sun Nov 1 10:46:46 2026
    From Newsgroup: comp.lang.forth

    Yay! Congrats!
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Marc Olschok@nobody@nowhere.invalid to comp.lang.forth on Sun Nov 1 22:51:12 2026
    From Newsgroup: comp.lang.forth

    On Sun, 01 Nov 2026 11:01:24 Anton Ertl wrote:
    Tomorrow it will be 18 years since we released Gforth 0.7.0, so it's
    time for a new release. It's also 34 years since we started Gforth in
    the summer of 1992, so it's about time for Gforth 1.0. We have
    released Gforth 1.0.0 on October 25, and have released 1.0.1 with
    mainly portability fixes yesterday.

    A historic moment. The end of of the 0.* era.
    --
    M.O.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Mon Nov 2 08:33:23 2026
    From Newsgroup: comp.lang.forth

    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    In particular, gforth-1.0.0 for AMD64 and ARM64 already exists on
    Docker, and you can run it with

    docker run -it --rm forthy42/gforth gforth

    (or use gforth-fast or gforth-itc instead of the last "gforth").

    However, currently there is only the tag "latest" for gforth images on >hub.docker.com, so when Bernd Paysan (forthy42) puts the next snapshot
    on hub.docker.com, you will get an upgrade to that. I hope he will
    add a tag for 1.0 or 1.0.1, and then the command above should look
    like

    docker run -it --rm forthy42/gforth:1.0 gforth

    Bernd Paysan has now built docker images with tags 1.0.0 and 1.0.1, so
    you can start, e.g., gforth-fast 1.0.1 with

    docker run -it --rm forthy42/gforth:1.0.1 gforth-fast

    One other aspect of Docker is: by default it does not allow the gforth
    engine running in the container to access files outside the container.

    I played around a little with the options --volume (-v), --mount, and
    --user (-u), but could not get the gforth in the container to write
    outside the container.

    But at least I managed to get it to read files that everyone is
    allowed to read:

    docker run -v /nfs/nfstmp:/nfs/nfstmp -it --rm forthy42/gforth:1.0.1 \
    gforth-fast /nfs/nfstmp/anton/gforth-amd64/onebench.fs

    I happen to have a file at /nfs/nfstmp/anton/gforth-amd64/onebench.fs,
    so the -v option mounted /nfs/nfstmp outside the container at
    /nfs/nfstmp inside the container, and then gforth-fast could access
    it. The following also works:

    docker run -v /nfs/nfstmp:/mymount -it --rm forthy42/gforth:1.0.1 \
    gforth-fast /mymount/anton/gforth-amd64/onebench.fs

    and makes it clearer which directory is which: /nfs/nfstmp is the
    directory outside the container, /mymount is the mount point inside
    the container, and the gforth-fast inside the container them accesses
    the file through that mount point.

    The Gforth shorthands for your home directory (~) and the home
    directories of other users (~<user>), or the working directory (~+) do
    not work as intended when using gforth running in docker. Any shell
    expansions that happen before docker passes the string to Gforth
    inside the container are unaffected by this, though.

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From albert@albert@spenarnc.xs4all.nl to comp.lang.forth on Mon Nov 2 18:38:15 2026
    From Newsgroup: comp.lang.forth

    In article <2026Nov1.110124@mips.complang.tuwien.ac.at>,
    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:

    I applaud that a modern version of gforth can be integrated in
    newer linux distribution, such that lazy people are inclined
    to install it.

    apt install gforth

    How I wished that the same could happen to ciforth ...

    <SNIP>

    ## Headline features

    * The text interpreter can recognize more things:
    * Additional ways to write literals in source code: scaled notation
    for FP numbers (6k5, 23%); strings ("string"), xts (`word),
    nts (``word), body addresses (<word>, <word+8>).
    * You can specify the vocabulary (or several) of a word, e.g.,
    `forth:and` vs. `assembler:and`.
    * Nonparsing syntax for dealing with value-flavoured and
    defer-flavoured words (`v` and `d` in the following examples): `->v`
    for `to v`; `+>v` for `+to v`; `'v` for `addr v`; `@>d` for
    `action-of d`; `=>d` for `is d`.
    * Contents of environment variables: `${LANG}`
    * You can extend the text interpreter with more **recognizers**

    Does the gforth team aspire to add these to upcoming standards?

    <SNIP>

    * C interface enhancements, includig callbacks.

    Interesting. What are the requirements in Forth speak of callbacks?
    It does contribute gui applications in Forth, but then
    a native MS-windows versions is indicated, I guess.

    - anton

    Groetjes Albert
    --
    The Chinese government is satisfied with its military superiority over USA.
    The next 5 year plan has as primary goal to advance life expectancy
    over 80 years, like Western Europe.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Mon Nov 2 17:54:03 2026
    From Newsgroup: comp.lang.forth

    albert@spenarnc.xs4all.nl writes:
    In article <2026Nov1.110124@mips.complang.tuwien.ac.at>,
    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:

    I applaud that a modern version of gforth can be integrated in
    newer linux distribution, such that lazy people are inclined
    to install it.

    apt install gforth

    This will take some more time, as there are signature issues to sort
    out. And then it will appear in Debian unstable, then testing, and
    only when Debian 14 is released, in stable.

    ## Headline features

    * The text interpreter can recognize more things:
    * Additional ways to write literals in source code: scaled notation
    for FP numbers (6k5, 23%); strings ("string"), xts (`word),
    nts (``word), body addresses (<word>, <word+8>).
    * You can specify the vocabulary (or several) of a word, e.g.,
    `forth:and` vs. `assembler:and`.
    * Nonparsing syntax for dealing with value-flavoured and
    defer-flavoured words (`v` and `d` in the following examples): `->v`
    for `to v`; `+>v` for `+to v`; `'v` for `addr v`; `@>d` for
    `action-of d`; `=>d` for `is d`.
    * Contents of environment variables: `${LANG}`
    * You can extend the text interpreter with more **recognizers**

    Does the gforth team aspire to add these to upcoming standards?

    What is proposed for standardization and is at the call-for-vote stage
    can be found at

    https://forth-standard.org/proposals/recognizer-committee-proposal-2025-09-11?hideDiff#reply-1686

    With that you can add the recognizers for scaled notation, strings,
    xts, nts, body addresses and voc:word notation (with caveats)
    yourself.

    For dealing with value-flavoured and defer-flavoured words, one would
    need to standardize a lot of carnal knowledge where the systems have
    little common ground, so I don't see standardization of the internals happening. Maybe at one point the various recognizer syntaxes will be standardized, but I don't expect that soon, and I will not work in
    that direction.

    For environment variables, one would need to standardize something
    like Gforth's getenv.

    The caveat about the voc:word notation is that we have no standardized
    way to know that voc is a vocabulary, so if somebody writes +:- or
    somesuch, a user-written recognizer will do things the user probably
    does not want (while Gforth's scope-recognizer with carnal knowledge
    sees that + is not a vocabulary and just does not recognize +:- ).

    * C interface enhancements, includig callbacks.

    Interesting. What are the requirements in Forth speak of callbacks?

    ?

    It does contribute gui applications in Forth, but then
    a native MS-windows versions is indicated, I guess.

    If you want GUI applications, Bernd Paysan provides MINOS2 for that.
    If you want to use some GUI framework written in C, you can use that,
    and call back from that into Forth code with the callback interface.

    As for MS Windows, I expect that you cannot call Windows GUI stuff
    from a Linux application running in WSL, at least not in the same
    process; maybe with an RPC interface: the Linux process does an RPC
    for some Windows call that is received by a Windows process that does
    the call to the OS. But if you want that, write it!

    There are no plans to build Gforth for Windows, but if anybody wants
    to give it a shot, go ahead. But take into account that Bernd Paysan
    has been there and eventually gave up. And he is not the guy who
    tends to pass such challenges. When I saw that Apple wanted us to
    jump through hoops to do native-code generation for MacOS, I was all
    for falling back to threaded code (with a resultant performance hit)
    on MacOS. Bernd took up the challenge and jumped through the hoops,
    so now the MacOS users get a fast Gforth despite MacOS.

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Mon Nov 2 18:42:07 2026
    From Newsgroup: comp.lang.forth

    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    Bernd Paysan has now built docker images with tags 1.0.0 and 1.0.1, so
    you can start, e.g., gforth-fast 1.0.1 with

    docker run -it --rm forthy42/gforth:1.0.1 gforth-fast

    One other aspect of Docker is: by default it does not allow the gforth
    engine running in the container to access files outside the container.

    I played around a little with the options --volume (-v), --mount, and
    --user (-u), but could not get the gforth in the container to write
    outside the container.

    I have now written a shell script that calls docker with a gforth
    engine and give it R/W access to your working directory and its
    subdirectories on the same file system.

    Download it from

    https://www.complang.tuwien.ac.at/forth/gforth/docker.sh

    Usage example:

    ./docker.sh gforth-fast onebench.fs

    This includes the file onebench.fs that's inside the container unless
    you happen to have a file onebench.fs in your working directory (the
    one inside the container leaves Gforth when finished, so the container
    also ends afterwards. But if you have myfile.4th in your working
    directory, you can say, e.g.,

    ./docker.sh gforth myfile.4th

    to include it.

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From albert@albert@spenarnc.xs4all.nl to comp.lang.forth on Thu Nov 5 11:50:50 2026
    From Newsgroup: comp.lang.forth

    In article <2026Nov2.185403@mips.complang.tuwien.ac.at>,
    <SNIP>
    There are no plans to build Gforth for Windows, but if anybody wants
    to give it a shot, go ahead. But take into account that Bernd Paysan
    has been there and eventually gave up. And he is not the guy who
    tends to pass such challenges. When I saw that Apple wanted us to
    jump through hoops to do native-code generation for MacOS, I was all
    for falling back to threaded code (with a resultant performance hit)
    on MacOS. Bernd took up the challenge and jumped through the hoops,
    so now the MacOS users get a fast Gforth despite MacOS.

    With ciforth I aspired to get a common denominator right.
    That works portably around ciforth and windows. Note that most
    of this is stored in the Library Accessible by Blocks.

    I had real strings long before. As prefixes for HEX etc.

    C has trail based the way for much things
    Operating system connection:
    "HOME" GET-ENV \ Why need a special notation?
    ARGC ARGV 1 ARG[] \ modelled after arg argcount and arg[]
    This is in the context of real native executable, for Windows too.
    Only available after
    WANT GET-ENV
    WANT ARG[]
    [ARGC must be in the kernel, to provide a hook. The remainder is in
    conditional libraries. The implementation of GET-ENV is totally
    non-portable.]

    All ciforth have three guises, interactive, script and executable.
    All observe the aforementioned os interface.

    <FORTH> -a
    Make the library accessable
    Scripts starts with
    #!<FORTH-PATH> -s
    (Accepting parameters in the script)

    I recently got the metacompiler for noforth running.
    This is a turnkey system that accepts -u (for writing uf2 files) -v (for building in vocabularies, i.e. wordlist) etc.
    It can be compiled on linux and ms windows, 32 and 64 bit.
    And also on riscv and arm 64 bit, probably on BSD, only 64 bit.
    The executable can be run without need of a ciforth installed, or
    even the notion that it was build by ciforth.
    (Caveat, tested on wine only.)

    I have made a midi player for windows.
    Likewise the executable can be run without need of a ciforth installed, or
    even the notion that it was build by ciforth.
    It cannot be run by linux, because linux has no drivers to play a midi event. (Nor can it run on a Windows if the multimedia stuff is lacking in SYSTEM32, but this is common in a PC that has a soundcard. )

    I doubt that drawing more and more stuff into the kernel is a good way.
    E.g. I would divide the "recognizers" in two groups:
    - general, available after ONLY
    - compartilised, in a wordlist.

    E.g. with a slight modification of WORD ( alias PARSE-NAME )
    and the help of PREFIX ciforth can parse lisp.
    However you cannot tolerate the renaming of e.g. `` ( '' without a
    context. That is simple, get lisp on top of the search order.

    https://github.com/albertvanderhorst/forthlisp

    Note that Forth parses a regular lisp file like coins.csm and run
    it like a lisp, then flips back with PREVIOUS to regular Forth.

    - anton

    Groetjes Albert
    --
    The Chinese government is satisfied with its military superiority over USA.
    The next 5 year plan has as primary goal to advance life expectancy
    over 80 years, like Western Europe.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Colin Tree@treecolin@gmail.com to comp.lang.forth on Thu Nov 12 10:39:03 2026
    From Newsgroup: comp.lang.forth


    Installed 1.0.0 from source, but I was lazy this time.
    .deb install works for the lazy, thanks.

    on starting, now reports
    :~$ gforth

    *terminal*:14432:209: warning: reopen lib failed /home/colin/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la:
    file not found

    file is available in /usr/lib/x86_64-linux-gnu/gforth/1.0.1/amd64/libcc-named/libgfdisasm2.la

    message appears to not cause problems-
    $ gforth cross.fs instructionset.fs nucleus.fs

    *terminal*:6704:209: warning: reopen lib failed /home/colin/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la:
    file not found

    - all files generated as expected.

    Colin


    On 3/11/26 03:38, albert@spenarnc.xs4all.nl wrote:
    In article <2026Nov1.110124@mips.complang.tuwien.ac.at>,
    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:

    I applaud that a modern version of gforth can be integrated in
    newer linux distribution, such that lazy people are inclined
    to install it.

    apt install gforth

    How I wished that the same could happen to ciforth ...

    <SNIP>

    ## Headline features

    * The text interpreter can recognize more things:
    * Additional ways to write literals in source code: scaled notation
    for FP numbers (6k5, 23%); strings ("string"), xts (`word),
    nts (``word), body addresses (<word>, <word+8>).
    * You can specify the vocabulary (or several) of a word, e.g.,
    `forth:and` vs. `assembler:and`.
    * Nonparsing syntax for dealing with value-flavoured and
    defer-flavoured words (`v` and `d` in the following examples): `->v`
    for `to v`; `+>v` for `+to v`; `'v` for `addr v`; `@>d` for
    `action-of d`; `=>d` for `is d`.
    * Contents of environment variables: `${LANG}`
    * You can extend the text interpreter with more **recognizers**

    Does the gforth team aspire to add these to upcoming standards?

    <SNIP>

    * C interface enhancements, includig callbacks.

    Interesting. What are the requirements in Forth speak of callbacks?
    It does contribute gui applications in Forth, but then
    a native MS-windows versions is indicated, I guess.

    - anton

    Groetjes Albert

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Thu Nov 12 09:18:39 2026
    From Newsgroup: comp.lang.forth

    Colin Tree <treecolin@gmail.com> writes:

    Installed 1.0.0 from source, but I was lazy this time.
    .deb install works for the lazy, thanks.

    on starting, now reports
    :~$ gforth

    *terminal*:14432:209: warning: reopen lib failed >/home/colin/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la:
    file not found

    file is available in >/usr/lib/x86_64-linux-gnu/gforth/1.0.1/amd64/libcc-named/libgfdisasm2.la

    message appears to not cause problems-
    $ gforth cross.fs instructionset.fs nucleus.fs

    *terminal*:6704:209: warning: reopen lib failed >/home/colin/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la:
    file not found

    - all files generated as expected.

    The effect is probably that DISASM2 will not work, and DISCODE should
    fall back to one of the other disassembly options. See

    <https://gforth.org/manual/1.0/Common-Disassembler.html>

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Thu Nov 12 12:04:49 2026
    From Newsgroup: comp.lang.forth

    Colin Tree <treecolin@gmail.com> writes:

    Installed 1.0.0 from source, but I was lazy this time.
    .deb install works for the lazy, thanks.

    on starting, now reports
    :~$ gforth

    *terminal*:14432:209: warning: reopen lib failed >/home/colin/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la:
    file not found

    file is available in >/usr/lib/x86_64-linux-gnu/gforth/1.0.1/amd64/libcc-named/libgfdisasm2.la

    I have sent your message to Bernd Paysan, and he guesses that
    libgfdisasm2.la (actually the .so file inside) links against a
    libopcodes with a different version number than the one on your
    system; this is, unfortunately, common. On his system,

    strace -f openat gforth

    outputs

    ....
    openat(AT_FDCWD, "/home/bernd/.cache/gforth/amd64/libcc-tmp/libgfdisasm2.la", O_RDONLY) = -1 ENOENT (Datei oder Verzeichnis nicht gefunden)
    openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/gforth/1.0.1/amd64/libcc-named/ libgfdisasm2.la", O_RDONLY) = 3
    openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/gforth/1.0.1/amd64/libcc-named/ libgfdisasm2.so.0", O_RDONLY|O_CLOEXEC) = 3
    openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
    openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/libopcodes-2.47.50- system.20261021.so", O_RDONLY|O_CLOEXEC) = 3
    openat(AT_FDCWD, "/usr/lib/x86_64-linux-gnu/libbfd-2.47.50- system.20261021.so", O_RDONLY|O_CLOEXEC) = 3
    ...

    Looking at the filenames of the last two openat calls makes it clear
    why such problems are common.

    We will see what we can do.

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.lang.forth on Fri Nov 13 06:26:27 2026
    From Newsgroup: comp.lang.forth

    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    We will see what we can do.

    Bernd Paysan has released Gforth 1.0.2, which is intended to reduce
    the problems with libgfdisasm2.la. Please try it and report the
    results.

    - anton
    --
    M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
    comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
    New standard: https://forth-standard.org/
    EuroForth 2026 CFP: http://www.euroforth.org/ef26/cfp.html
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Colin Tree@treecolin@gmail.com to comp.lang.forth on Fri Nov 13 17:42:48 2026
    From Newsgroup: comp.lang.forth

    Thanks Anton and Bernd,
    my system has /lib/x86_64-linux-gnu/libopcodes-2.44-system.so
    upgrade to 1.0.2 works

    see *
    Code *
    $55CE696D5A94: mov %r15,0x50(%r14)
    $55CE696D5A98: add $0x8,%r15
    $55CE696D5A9C: mov 0x8(%r13),%rax
    $55CE696D5AA0: mov 0x0(%r13),%rdx
    $55CE696D5AA4: add $0x8,%r13
    $55CE696D5AA8: imul %rdx,%rax
    $55CE696D5AAC: mov %rax,0x0(%r13)
    $55CE696D5AB0: mov (%r15),%rcx
    $55CE696D5AB3: jmp *%rcx
    end-code
    ok


    Go well,
    Colin

    On 13/11/26 16:26, Anton Ertl wrote:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    We will see what we can do.

    Bernd Paysan has released Gforth 1.0.2, which is intended to reduce
    the problems with libgfdisasm2.la. Please try it and report the
    results.

    - anton

    --- Synchronet 3.22a-Linux NewsLink 1.2