C.CodeCompared.To/Forth

The compiler, the linker, the loader and the shell are all one program, and it is small enough to sit in the ROM of the device being programmed. That is how Forth was used on telescopes and satellites: a developer typed definitions over a serial line and ran them on the target at once, with no edit-compile-flash cycle at all.

A format string is a way of telling the callee what types its variadic arguments have — which the compiler cannot check and -Wformat tries to. Forth has no types for a format to describe, so the choice of word is the format, and printing −1 with U. shows the same bits as 0xFFFFFFFFu.

A C calling convention puts the arguments in registers or a stack frame and gives each one a name. Forth has two stacks, both visible: the data stack for arguments and results, and the return stack for return addresses — which words may borrow for temporaries, as >R does here, provided everything is moved back before ;.

These four are each a single instruction or two in most Forth implementations, which is why Forth code can be nearly as fast as unoptimized C. A value used twice costs a DUP; in C, the compiler finds that out for itself.

The Forth advice for a word that needs many locals is not to find a way to name them but to split the word, until each piece touches only two or three values. Forth 2012 does define local variables, {: … :}, in an optional word set — this page's Forth lacks it, and many Forth programmers never use it.

A C prototype exists so the compiler can check the call and the linker can find the function later. Forth has no separate link step — a word is compiled straight into memory and a call is resolved to its address immediately — so there is nothing for a forward declaration to say. For the rare genuine forward reference, such as mutual recursion, Forth uses a DEFERred word.

When the second number reaches zero, ?DUP leaves only the answer and the IF body is skipped. The recursive call is the last thing the word does, but Forth does not promise to turn it into a jump; like C, a deep enough recursion runs out of return stack.

C needs pointer parameters (or a struct) to return two values, and the caller has to allocate somewhere for them to land. Forth returns both the same way it returns one, with nothing allocated and nothing addressed. The final SWAP . . prints the quotient first to match the C output.

CELLS is sizeof for the one type Forth has. The C column names int32_t to match this page's Forth, whose cells are 32 bits; on a 64-bit Forth 1 CELLS is 8, and portable Forth code writes CELLS rather than 4 for the same reason portable C writes sizeof.

In C, INT32_MAX + 1 on a signed type is undefined behavior that an optimizer is entitled to assume never happens, which is why the C column does the addition on unsigned values and converts. Forth has no signed or unsigned types, only signed and unsigned words — . and U., < and U< — applied to the same bits, so wrapping is simply what happens.

C89 let / round either way for negative operands, and C99 fixed it to truncate. Forth still leaves plain / and MOD to the implementation, and names both behaviors explicitly: SM/REM for C's, and FM/MOD for floored division, whose remainder takes the divisor's sign.

The C version has to widen to int64_t by hand for the product and narrow again afterward, and forgetting the cast is a classic overflow. */ builds the widening in, which is why it is one of the most used words in embedded Forth, where there is often no floating-point unit at all.

A small word like BIT is what C would write as a macro, #define BIT(n) (1u << (n)). In Forth there is no difference between a macro and a function for something this small, and no parentheses to forget around the argument.

Every Forth variable behaves like a C pointer that is dereferenced by hand. There is no implicit load or store anywhere in the language, which is why a Forth programmer reading code always knows exactly where memory is touched.

C scales element += 2 by sizeof(int32_t) because a C pointer carries its target type. A Forth address carries nothing, so the scaling is explicit — which also means VALUES 2 + @, missing the CELLS, is not a type error but a fetch from the middle of the first element.

Both columns print 44 33 22 11: the machine underneath is little-endian. In C, reading an object's bytes needs a cast to a character pointer, which is one of the few aliasing conversions the standard permits; in Forth there is nothing to cast, because an address was never a pointer to anything in particular.

This is a bump allocator, and it is the core of Forth's memory model: space is claimed in order and never individually freed. Most embedded C code on small microcontrollers avoids malloc for the same reasons — fragmentation and unpredictable timing — and allocates statically at startup, which is exactly what this is. Forth also offers ALLOCATE and FREE in an optional word set.

MOVE behaves like memmove, handling overlapping regions correctly, so there is no Forth equivalent of choosing the wrong one of memcpy and memmove. TYPE prints exactly 12 bytes, just as %.12s does, since neither buffer ends in a zero.

Defining the indexing word once is what keeps the scaling out of every use. C's samples[index] is defined as *(samples + index), and I SAMPLE @ is that definition spelled out with the scaling made visible.

0 >MAXIMUM is the same trick as the classic C definition of offsetof, which takes a member's address from a null pointer. Nothing ties the field words to PROBE, so they work on any three cells anywhere — the flexibility and the danger of a C cast, without the cast.

This is what a C compiler does when it lays out a struct, done by the program instead — without padding, since these sizes are chosen to line up. Forth 2012 standardizes the same idea as +FIELD; the whole mechanism is three lines because CREATE and DOES> give every Forth programmer the power C reserves for its compiler.

C marks the end of a string with a zero byte, so strlen has to scan for it and a string cannot contain a zero. A Forth string's length travels with its address, so finding the length costs nothing and any byte value is allowed — the same design as Go's and Rust's slices, arrived at in 1970.

C can only do this with a precision in the format string or by writing a terminator into the buffer, because a char * alone cannot say where to stop. In Forth every string is already a slice, so taking part of one is address arithmetic and nothing is copied.

Counted strings are the older Forth format, still used where a string has to be stored in memory or passed as one value, and they limit a string to 255 bytes. Address-and-length pairs replaced them for everything else, much as C code increasingly passes a pointer and a size_t instead of relying on the terminator.

strcmp has to walk both strings to their terminators; here the length check makes the common "different length" case free. Many Forths provide COMPARE, which orders strings like memcmp, in the optional string word set.

Five #s are %05d. The digits are generated from the right, by repeated division, which is how every itoa works inside; Forth simply exposes the loop as words, so a program can insert a decimal point with HOLD or a sign with SIGN at any position.

IF … ELSE … THEN compiles to exactly the conditional branch and jump a C compiler emits for if … else; the words are that direct. They only work inside a definition, because at the top level there is no code being compiled for a branch to jump over.

A DO loop keeps its index and limit on the return stack, much as a C compiler keeps a loop counter in a register. That is also why a word must not leave a DO loop with EXIT without first calling UNLOOP: the return stack would still hold the loop's counters instead of the address to return to.

DO is a do-while: it runs the body before testing, so 0 0 DO would count upward, wrap through all 2³² possible values and only then stop. The C loop tests before the first iteration; ?DO is the Forth word that does the same.

An execution token is a function pointer without a signature: the compiler cannot warn about calling it with the wrong arguments, because no word has a declared argument list for it to compare against. Calling through a token costs one indirect call, the same as in C.

A jump table is the reason a C switch over dense values is fast, and it is the reason Forth needs no switch for dispatch: the table is ordinary data. A real one would check the index first, since, exactly as in C, an index past the end fetches whatever is stored there and jumps to it.

The comparison token rides on the data stack, under the last index, and 3 PICK copies it up for each comparison. 🚨 It cannot be parked on the return stack with >R and read inside the loops with R@, the way a C programmer might reach for a register: each DO keeps its index and limit on that same return stack, so R@ would return a loop counter and EXECUTE would jump to it. Inside the inner loop I is the position; J would be the pass.

A #define is text substitution, resolved before the compiler sees the code and invisible to a debugger. A Forth constant is a real word in the dictionary, which the interactive system can print, test and use immediately — and there is no separate preprocessor language with its own rules to learn.

The C macro exists to avoid a function call and to work on any integer type, and it pays with parentheses around every argument and with evaluating value up to three times. The Forth word takes its arguments from the stack, so each is computed exactly once, and with no types there is only one version to write. A Forth word this small is often compiled inline by an optimizing Forth anyway.

C restricts compile-time computation to constant expressions — or to templates and constexpr in its descendants. Between [ and ] any Forth word at all can run, including ones the program itself defined a moment earlier.

The C macro is text pasted in before compilation, and it quietly declares a variable named repetition that could collide with one of yours. The Forth version runs as real code inside the compiler and inserts compiled loop instructions — no text, no names to collide, and it can compute anything it likes along the way. IF, DO and ; are immediate words defined in exactly this way.

C needs a cast to turn a number into an address and volatile to stop the optimizer from caching what it reads. Forth needs neither: nothing is optimized away behind your back, and at a live Forth prompt on a board, LED-ON typed over the serial line lights the LED at once. That immediacy is why Forth is still used to bring up new hardware.

The C table goes into read-only memory because it is const and static. On a Forth system that compiles to flash, the dictionary itself — code and tables alike — is what gets written to ROM, so a table defined like this is already where a C linker would have placed it.

Like the C version, this buffer does not check for being full or empty, which keeps the example the same size in both columns. Passing the variable's address to ADVANCE, rather than its value, is Forth's everyday version of passing a pointer so the callee can update it.

An address-and-length pair is Forth's standard way to pass a buffer, and it is the signature this C function already has. The only difference is where sum lives: in a local in C, and on the stack, under the address, in Forth.

The C function returns its status and writes the result through a pointer; the Forth word returns both on the stack, and returns a different number of items depending on the outcome. That is legal and common in Forth, and it is exactly the kind of contract only the stack-effect comment records.

In C, exit ends the process. ABORT" ends only the current command: on an interactive Forth the system is back at its prompt with every word still defined, which is what makes aborting a safe way to handle a mistake typed at a live board. Both programs stop before the third call, and both exit with a failure, which is expected here.

This is setjmp/longjmp with the two sharp edges removed: the stack depth is restored for you, so the argument PARSE-FIELD consumed comes back as a placeholder that the DROP removes, and the return stack is unwound properly instead of being abandoned. CATCH and THROW are the optional exception word set, which this page's Forth does not include.

Nothing in Forth says what size the data at an address is, so choosing @ where C@ was meant is not a type error — it silently reads 263. In C, dereferencing a uint8_t * can only ever read one byte, and the C column has to assemble the whole 32-bit value by hand to get the same 263.

C decides which comparison to perform from the operand types, and mixing an int with an unsigned silently converts the int — a famous source of bugs, and the reason for -Wsign-compare. Forth makes the programmer choose the word each time, which is more to remember and impossible to get implicitly.

A C toolchain sorts functions into .text and arrays into .data no matter how the file is ordered. Forth does not separate them, so defining a word between a CREATE and the ,s meant for it puts the word's code where the array was supposed to be, and the "array" then holds machine code. The rule is to finish laying down data before defining anything else.