openfirmware

I got a quick reply from Mitch Bradley! Yes I wrote a paper but I probably can't find it. The easiest place to look would be in the Open Firmware source. https://github.com/MitchBradley/openfirmware/blob/master/for... The magic is all in +level and -level. Search for those in kernel.fth to see other places they are used to achieve a similar effect, e.g. in abort" For an alternative but effectively equivalent formulation, see: https://github.com/MitchBradley/cforth/blob/master/src/cfort... and https://github.com/MitchBradley/cforth/blob/master/src/cfort... [...] https://news.ycombinator.com/item?id=29264309 In PostScript that would be: /PostScript Know? { Honk! } { /PostScript Learn! } ifelse FORTH doesn't have an IFELSE unless you define it yourself of course, but it would have no way of telling which part of your code was the conditional, part to do if true, or part to do if false, since white space and line breaks have no meaning to it, except for a few cases like \ comments. The IF comes between the conditional and the part to do if true, the ELSE comes between the part to do if true and the part to do if false, and the THEN comes at the end. The structure of PostScript code, conditionals, and flow control is homoiconic, made of nested arrays, like polymorphic JSON arrays, where FORTH code is flat untyped arrays of threaded pointers with relative branching. Forth has an "inner interpreter" called NEXT that threads from one pointer to the next (sometimes implemented as one machine language instruction, or just a few), and also an "outer interpreter" or compiler that translates text into threaded code for the inner interpreter. https://en.wikipedia.org/wiki/Polymorphism_(computer_science... https://en.wikipedia.org/wiki/Homoiconicity https://en.wikipedia.org/wiki/Threaded_code Here's Mitch Bradley's implementation of interactive control structures (IF, ELSE, THEN, BEGIN, UNTIL, AGAIN, REPEAT, WHILE, DO, LOOP, etc) in the outer interpreter of his FORTH system, which actually allows you to use conditionals and loops at the interactive top level of the interpreter, not just in compiled words (which solves a traditional and frustrating limitation of classic FORTH). https://github.com/MitchBradley/openfirmware/blob/master/for... Here is an alternative but equivalent implementation of interactive Forth control structures in his CForth (Forth implemented in C, of course): https://github.com/MitchBradley/cforth/blob/master/src/cfort... Here's some more of Mitch's beautiful code from OpenFirmware, his Forth kernel meta-compiler written in Forth, which supports 8, 16, 32, an 64 bit, big-endian and little-endian architectures, as well as direct, indirect, and token threaded code: https://github.com/MitchBradley/openfirmware/blob/master/for... https://en.wikipedia.org/wiki/Threaded_code#Direct_threading https://en.wikipedia.org/wiki/Threaded_code#Indirect_threadi... https://en.wikipedia.org/wiki/Threaded_code#Token_threading [...] https://news.ycombinator.com/item?id=29265144 Some FORTH systems even have a "metacompiler" that lets one FORTH system compile another FORTH system for the same or different CPU, word size, byte order, threading technique, with or without a built-in compiler, etc, from the same source code! OpenFirmware (the FORTH burnt into boot roms of SPARC, PowerPC, OLPC, and other systems) is a great highly refined example that supports many different architectures: openfirmware/forth/kernel/metacompile.fth https://github.com/openbios/openfirmware/blob/master/forth/k... openfirmware/forth/kernel/meta1.fth https://github.com/openbios/openfirmware/blob/master/forth/k... The OpenFirmware kernel is a Forth meta-compiler, which can compile itself on any architecture, and also cross-compile for different target architectures. It has cross-architecture extensions to FORTH (like \16 \32 comments and /n /n* generically typed words) that make it possible to write platform, word size, byte order, and threading independent code, and compile images (stripped or with headers) for embedded systems (like the OLPC boot ROMs) and new CPU architectures (like Sun's transition from 68K to SPARC), and share code with a more powerful development environments. https://en.wikipedia.org/wiki/Compiler-compiler#Forth_metaco... [...] https://news.ycombinator.com/item?id=29264489 [...] Here's some IBM-PC Forth for the CAM-6 cellular automata machine that was block based -- check out the unique idiosyncratic right-justified reverse-indentation style (starting with KGET), which is not standard Forth style, but sure looks cool and poetic, like E E CUMMINGS ON CAPS LOCK: https://donhopkins.com/home/code/tomt-cam-forth-scr.txt https://donhopkins.com/home/code/tomt-users-forth-scr.txt [...] https://news.ycombinator.com/item?id=29261868 Coco Conn and Paul Rother wrote this up about what they did with FORTH at HOMER & Assoc, who made some really classic music videos including Atomic Dog, and hired Charles Moore himself! Here's what Coco Conn posted about it, and some discussion and links about it that I'm including with her permission: [...] Forth & Charles Moore We hired Forth, Inc. and got Charles Moore, the inventor of FORTH to program the console host computer. I learned FORTH and worked with Charles. I programmed the 2K byte EPROM in each visual channel. On the Master Z80 system we ran PolyForth a multi tasking system in 32K bytes. We had an extra 16K RAM for buffers and things. If I remember right, the system ran four tasks, but that was 20 years ago, my memory may be hazy. Anyway, I learn not only FORTH from Charles Moore, but also how to factor code in to small reusable routines, WORDs they're called in FORTH. I learned Object Oriented Programming without knowing it. Also a lot of use of vectors. Its a cool language. Charles Moore was a great inspiration to me, and really taught me a great deal that they never taught me in computer programming school. [...]

rmware, portable device drivers, hardware and driver configuration, and many hardware platforms. https://github.com/MitchBradley/openfirmware This is an implementation of Open Firmware, a processor-independent firmware design. Open Firmware is specified by IEEE 1275-1994, Standard for Boot (Initialization, Configuration) Firmware. The IEEE standard designation lapsed in 1999, when the Open Firmware working group declined to go through the rather time-consuming IEEE reaffirmation process, but the design lives on. This implementation was written primarily by Mitch Bradley, the original author of Open Firmware. The bulk of the recent development was done at Firmworks by Bradley and colleagues. It traces its roots back to the original Open Boot firmware implementation that Bradley developed at Sun Microsystems in the late 80s and early 90s. That in turn had roots in Forthmacs, a Forth programming language implementation developed and marketed during the early 80s by Bradley Forthware. And Forthmacs, in turn, owes a debt of gratitude to the public domain Forth implementations F83, developed by Michael Perry, and MVP Forth, by Glen Haydon. Lilian Walter wrote the USB stack. https://news.ycombinator.com/item?id=29279022 DonHopkins on Nov 19, 2021 | parent | context | favorite | on: Forth vs Lisp The inner interpreter of Mitch Bradley's portable and efficient CForth is simply implemented with a big switch statement, in the function called "inner_interpreter". The C compiler typically compiles that code with the big switch statement into an efficient jump table, behind the scenes. https://github.com/MitchBradley/cforth/blob/master/src/cfort... Properly speaking, that's a token threaded interpreter, since it switches on token numbers in the code field, instead of indirecting function through pointers to the C equivalent of "code" words. https://en.wikipedia.org/wiki/Threaded_code#Token_threading https://news.ycombinator.com/item?id=27484426 DonHopkins on June 12, 2021 | root | parent | next [–] From https://news.ycombinator.com/item?id=21823081 I wrote malloc.fth for Mitch Bradley's ForthMacs, which ended up in OpenFirmware: https://github.com/openbios/openfirmware/blob/master/ofw/cor... [...] https://news.ycombinator.com/item?id=21822840 DonHopkins on Dec 18, 2019 | parent | context | favorite | on: Thoughts on Forth Programming Here's the interview with Mitch Bradley saved on archive.org: https://web.archive.org/web/20120118132847/http://howsoftwar... I've previously posted some stuff about Mitch Bradley -- I have used various versions of his ForthMacs / CForth / OpenFirmware systems, and I was his summer intern at Sun in '87! Mitch is an EXTREMELY productive FORTH programmer! He explains that FORTH is a "Glass Box": you just have to memorize its relatively simple set of standard words, and then you can have a complete understanding and full visibility into exactly how every part of the system works: there is no mysterious "magic", you can grok and extend every part of the system all the way down to the metal. It's especially nice when you have a good decompiler / dissassembler ("SEE") like ForthMacs, CForth, and OpenFirmware do. https://news.ycombinator.com/item?id=9271644 [...]

ware/tree/master/cpu/x86 purpose: From Forth, call the C subroutine whose address is on the stack https://github.com/openbios/openfirmware/blob/master/cpu/x86... purpose: Tools for creating disembodied assembly code sequences https://github.com/openbios/openfirmware/blob/master/cpu/x86... purpose: Forth access words for special 386 registers https://github.com/openbios/openfirmware/blob/master/cpu/x86... purpose: After a breakpoint, displays a backtrace of C stack frames. https://github.com/openbios/openfirmware/blob/master/cpu/x86... purpose: 386 disassembler. https://github.com/openbios/openfirmware/blob/master/cpu/x86... purpose: Access to I/O ports and physical addresses under Linux https://github.com/openbios/openfirmware/blob/master/cpu/x86... https://github.com/openbios/openfirmware/blob/master/cpu/x86... \ One of the very best features of FORTH assemblers is the ability \ to use structured conditionals instead of branching to nonsense \ labels. : IF >MARK swap long-offsets @ if dup h# eb = if drop h# e9 asm8, else prefix-0f h# 10 + asm8, then real? if 0 asm16, else 0 asm32, then else ASM8, 0 asm8, then ; : THEN >RESOLVE ; : BEGIN <MARK ; : UNTIL <RESOLVE ; : AHEAD 0EB IF ; : ELSE AHEAD BUT THEN ; : AGAIN 0EB UNTIL ; : WHILE IF BUT ; : REPEAT AGAIN THEN ; \ These conditional test words leave the opcodes of conditional \ branches to be used by the structured conditional words. \ For example, \ 5 # ECX CMP 0< IF EAX EBX ADD ELSE EAX EBX SUB THEN \ begin dx al in tbe # al and 0<> until https://github.com/openbios/openfirmware/blob/master/cpu/x86... \ Some x86 assembler macros to make it easier to write x86 early \ startup code. There are macros to set MSRs to specific values, \ to set and clear individual MSR bits, to read and write PCI \ configuration registers with the common CF8/CFC mechanism, \ and to read and write I/O ports. \ The code keeps the MSR register number in %ecx, the low 32 bits \ of the value in %eax, and the high 32 bits in %edx, consistent \ with the way the rdmsr and wrmsr machine instructions work. \ The bitset and bitclr operations work on %eax, and the -hi versions \ work on %edx. \ The I/O port operations also leave the data in %eax, so you can \ use bitset and bitclr with them too.

ers like 0, 1, -1 and others are hard coded, not just for speed but also for space: a call to a code word only takes one cell, instead of using two cells with a LIT [value]. Here's some Breshenham line code I first wrote in FORTH (Mitch Bradley's SunForth on a 68k Sun-2 with cg2 graphics board), then translated to 68k code (using the rpn FORTH assembler) -- the FORTH code is commented out before the corresponding assembly code: https://donhopkins.com/home/archive/forth/cg/line.f [...] https://news.ycombinator.com/item?id=17480298 Cool! Does it include a FORTH 6502 assembler written in FORTH? I love writing assembly code in RPN with Forth macros! You can write FORTH code with loops and conditionals and any kind of logic and parameters, that dynamically assembles machine code! Much better than your typical macro assembler. Here's some 6502 assembler for an Apple ][ SUPDUP terminal emulator that does ram card bank switching: http://www.donhopkins.com/home/archive/forth/supdup.f [...] https://news.ycombinator.com/item?id=22456471 In what way is PostScript worse than Forth? Please answer with specific details, and provide links to code if you can. I programmed a lot of Forth code before learning and moving on to programming a lot of PostScript code, so I've used each of them extensively, and much prefer PostScript, and I'm happy to show you why and explain by showing you code. [...] https://news.ycombinator.com/item?id=21968175 Kragen is right that PostScript is a lot more like Lisp or Smalltalk than Forth, especially when you use Owen Densmore's object oriented PostScript programming system (which NeWS was based on). PostScript is semantically very different and much higher level that Forth, and syntactically similar to Forth but uses totally different names (exch instead of swap, pop instead of drop, etc). [...]

d versions: https://github.com/openbios https://github.com/openbios/openbios https://github.com/openbios/openfirmware https://github.com/openbios/openboot https://github.com/openbios/smartfirmware https://openfirmware.info/Welcome_to_OpenBIOS https://openfirmware.info/Open_Firmware https://github.com/MitchBradley/openfirmware Also there's also Mitch's very portable "cforth": https://github.com/MitchBradley/cforth There's even an Open Firmware Song: https://www.youtube.com/watch?v=b8Wyvb9GotM

ny architecture, and also cross-compile for different target architectures. It has cross-architecture extensions to FORTH (like \16 \32 comments and /n /n* generically typed words) that make it possible to write platform, word size, byte order, and threading independent code, and compile images (stripped or with headers) for embedded systems (like the OLPC boot ROMs) and new CPU architectures (like Sun's transition from 68K to SPARC), and share code with a more powerful development environments. https://en.wikipedia.org/wiki/Compiler-compiler#Forth_metaco... >Many advocates of the language Forth call the process of creating a new implementation of Forth a meta-compilation and that it constitutes a metacompiler. The Forth definition of metacompiler is: >"A metacompiler is a compiler which processes its own source code, resulting in an executable version of itself." >This Forth use of the term metacompiler is disputed in mainstream computer science. See Forth (programming language) and History of compiler construction. The actual Forth process of compiling itself is a combination of a Forth being a self-hosting extensible programming language and sometimes cross compilation, long established terminology in computer science. Metacompilers are a general compiler writing system. Besides the Forth metacompiler concept being indistinguishable from self-hosting and extensible language. The actual process acts at a lower level defining a minimum subset of forth words, that can be used to define additional forth words, A full Forth implementation can then be defined from the base set. This sounds like a bootstrap process. The problem is that almost every general purpose language compiler also fits the Forth metacompiler description. >When (self-hosting compiler) X processes its own source code, resulting in an executable version of itself, X is a metacompiler. >Just replace X with any common language, C, C++, Pascal, COBOL, Fortran, Ada, Modula-2, etc. And X would be a metacompiler according to the Forth usage of metacompiler. A metacompiler operates at an abstraction level above the compiler it compiles. It only operates at the same (self-hosting compiler) level when compiling itself. One has to see the problem with this definition of metacompiler. It can be applied to most any language. >However, on examining the concept of programming in Forth, adding new words to the dictionary, extending the language in this way is metaprogramming. It is this metaprogramming in Forth that makes it a metacompiler. >Programming in Forth is adding new words to the language. Changing the language in this way is metaprogramming. Forth is a metacompiler because Forth is a language specifically designed for metaprogramming. Programming in Forth is extending Forth adding words to the Forth vocabulary creates a new Forth dialect. Forth is a specialized metacompiler for Forth language dialects. Mitch's OpenFirmware code is one end of the readability spectrum. But for shock value, here are some beautiful but inscrutable FORTH code excerpts that define cellular automata rules with lots of deeply nested conditionals around mysterious but exquisitely indented BEEPS and BOOPS and line noise that makes Perl look clean and elegant. ;) https://donhopkins.com/home/code/tomt-users-forth-scr.txt ( A-BOMB) 24 LOAD : KN C0 X0 Y0 Z0 + + + C1 X1 Y1 Z1 + + + * 0> ; : KC C0 C1 * X0 X1 * Y0 Y1 * Z0 Z1 * + + + 0> ; : EXPL X1 Y1 + X1 Y1 * - ; : RULE0 C0 KN IF DROP 0 THEN KC IF DROP 0 THEN C0 C1 * 1 = IF DROP 1 THEN ; : RULE1 Z1 KN IF DROP EXPL THEN KC IF DROP 0 THEN C0 C1 * 1 = IF DROP 1 THEN ; ( CASEN ) FORGET TASK : TASK ; : NSUM NORTH SOUTH EAST WEST N.WEST N.EAST S.WEST S.EAST CENTER + + + + + + + + ; : CASEN NSUM 0 = IF 0 ELSE NSUM 1 = IF 0 ELSE NSUM 2 = IF 1 ELSE NSUM 3 = IF 0 ELSE NSUM 4 = IF 0 ELSE NSUM 5 = IF 0 ELSE NSUM 6 = IF 0 ELSE NSUM 7 = IF 0 ELSE NSUM 8 = IF 0 ELSE NSUM 9 = IF 0 ELSE THEN THEN THEN THEN THEN THEN THEN THEN THEN THEN ; <T> ( BRAIN ) 36 LOAD : CENTERS CENTER1 2 * CENTER + ; : FEEP CENTERS 0 = IF 1 ELSE CENTERS 1 = IF 0 ELSE CENTERS 2 = IF 0 ELSE CENTERS 3 = IF 0 ELSE THEN THEN THEN THEN ; : RULE CASEN FEEP AND ; <T> f1 BBM01 ( READY ) FORGET TASK : TASK ; : CENTERS CENTER1 2 * CENTER + ; : READY CENTERS 0 = IF 1 ELSE CENTERS 1 = IF 0 ELSE CENTERS 2 = IF 0 ELSE CENTERS 3 = IF 0 ELSE THEN THEN THEN THEN ; <T> ( PUCCIO1) 24 LOAD : K7 C0 C1 * X0 X1 * Y0 Y1 * Z0 Z1 * + + + 0<> ; : K71 C0 C1 X0 1 X1 Y0 Y1 Z0 Z1 + + + + + * * * 1 = ; : K72 X0 X1 Z0 1 C0 C1 Y0 Y1 Z1 + + + + + * * * 1 = ; : K73 Z0 Z1 Y0 1 Y1 C0 C1 X0 X1 + + + + + * * * 1 = ; : K74 Y0 Y1 C0 1 C1 X0 X1 Z0 Z1 + + + + + * * * 1 = ; : K81 X0 X1 Y0 1 C0 C1 Z0 Z1 Y1 + + + + + * * * 1 = ; : K82 Z0 Z1 C0 1 X0 X1 Y0 Y1 C1 + + + + + * * * 1 = ; : K83 Y0 Y1 X0 1 Z0 Z1 C0 C1 X1 + + + + + * * * 1 = ; : K84 C0 C1 Z0 1 Y0 Y1 X0 X1 Z1 + + + + + * * * 1 = ; --> : RULE0 Y1 ( X1 Z1 + Z1 Y1 + Y1 C1 + * * 1 = IF DROP C1 THEN ) K7 IF DROP Z0 THEN K71 IF DROP 0 THEN K72 IF DROP 1 THEN K73 IF DROP 0 THEN K74 IF DROP 1 THEN K81 IF DROP 0 THEN K82 IF DROP 1 THEN K83 IF DROP 1 THEN K84 IF DROP 0 THEN ; ( DOUBLE GAS etoile on P0 and P1) 24 LOAD : KK C0 X0 Y0 Z0 + + + 1+ C1 X1 Y1 Z1 + + + 1+ * 5 = ; ( rotate right/left w/collisions ) : RULE0 KC0 IF C0 ELSE T0 0= IF Y0 ELSE X0 THEN THEN KK IF DROP C1 THEN ; ( diagonal gas, w/collisions) : RULE1 KC1 IF X1 ELSE Z1 THEN KK IF DROP C0 THEN ; BBM01 https://donhopkins.com/home/code/tomt-cam-forth-scr.txt ( MENU of keys ) VARIABLE UNFLG : ?UNDEF UNFLG @ IF OUT @ SWAP $. OUT @ - 6 + SPACES ." is undefined" ELSE DROP THEN ; : K. ( string.addr --) FIND IF OUT @ OVER >NAME .NAME OUT @ - 6 + SPACES >BODY BEGIN DUP @ ['] ;S <> WHILE DUP @ >NAME .NAME 2+ REPEAT DROP ELSE ?UNDEF THEN ; ( == creates fast code words for picking out bits of variable X) VARIABLE X CODE X! AX POP X , AX MOV NEXT, END-CODE CODE X@ AX, X MOV AX PUSH NEXT, END-CODE CREATE ZPUSH ASSEMBLER 1$ JNZ AX, # 0 MOV AX PUSH NEXT, 1$: AX, # 1 MOV AX PUSH NEXT, : X? ( mask byt#-) ASSEMBLER AL, X + MOV AL, # TEST ZPUSH JMP ; 0 CARRAY 2^N 1 C, 2 C, 4 C, 8 C, 10 C, 20 C, 40 C, 80 C, : == ( bit# --) ( ---- name ) >R [COMPILE] CODE R> 8 /MOD SWAP 2^N C@ SWAP X? ASSEMBLER [COMPILE] END-CODE ; 1 == NORTH 3 == WEST 5 == N.WEST 7 == S.WEST 9 == CENTER1 2 == SOUTH 4 == EAST 6 == N.EAST 8 == S.EAST 0 == CENTER ( eg. NORTH will return bit #1 of X when executed ) --> : #DX! ASSEMBLER DX, # MOV ; : #AL! ASSEMBLER AL, # MOV ; : AL.IN ASSEMBLER AL, DX IN ; : AL.OUT ASSEMBLER DX, AL OUT ; : SRCE BEGIN ?STEPPING @ (?TERMINAL) NOT AND WHILE STEPPING REPEAT (?TERMINAL) DLAST @ AND DNUM @ 0= OR SRCE.SEG SPOINT @ @L 0= OR IF SAVE.INPUT KSAV ELSE SRCE.SEG SPOINT GET DUP KPUT DUP DLAST C! THEN ;

sbcl/sbcl/blob/master/src/code/defstruct.... FORTH: https://github.com/openbios/openfirmware/blob/master/forth/l...

, but it's nice to have a pure FORTH implementation for embedded applications.

for embedded applications.