TODO.org

North: Bash Bootstrap

Goals

Ultimate:

ELF file that only has an offset thread into a dynamically linked symbol table and interpreter.

Primary:

Build an ELF file that can execute the code to build itself.

Secondary:

North Runner compatible with the x86 runner that can mmap a file to execute.

Thirdly

Get out of the Turing Tar Pit. Make a useful program like a game.

Fourthly

A fully self contained binary that can output its own code that can be used to rebuild.

• minimal features
• full features

Tasks

May

Strings as seqn with length.

March

Swap string length returns to length string ordering. SeqN for free.

Literalizer for float32

Recognized as a literalizer.

Compile token enum

Decompiler output

Float and fixed output when the fraction is zero.

parse-float with exponents

TTY reader

data script error handling: need to abort the tests

comparisons need to return true / -1 and false / 0.

make-typed-pointer print out

FFB15684:-5155192 > 3 integer make-typed-pointer
FFB15678:-5155204 > dup print-instance
FFB1567C:0 integer (B364283F) < value

  0:4 pointer<any> name 16843078 1010146
  4:4 uint<32> byte-size 0 0
  8:4 pointer<any> super 0 0
  12:4 pointer<any> data 671089408 28000300

Should print like a struct with a single field.

value-of’s offset detection may fail w/ stack addresses.

Types and structs for existing data like dictionary entries.

Jan 24

Interfaces

Collection of functions that specialize on one or more argument types. Would extend the . and -> operators with mini dictionaries. Might be a base to build struct fields.

  interface Animal
    def say
      hello
    end
    def walk
    end
  end

  struct: Duck
  value field: flying

  Duck implements Animal
    def say
      quack
    end
  end

  struct: Fish
  Fish implements Animal
    def say
      bloop bloop
    end
    def walk
      flop
    end
  end

  Duck make-instance
  dup Animal -> say ( quack )
  dup Animal -> walk
  dup Instance -> print

  Fish -> new
  dup Animal -> say ( bloop bloop )
  dup Animal -> walk
  dup Instance -> print

interface Number
  def +
  end
end

int<32> implements Number
  def + arg1 int<32> coerce arg0 int-add 2 return1-n end
end
float<32> implements Number
  def + arg1 float<32> coerce arg0 float32-add 2 return1-n end
end
3.14 2.0 Number . +
3.14 make-float<32> 2.0 make-float<32> Number -> +

Top level s" copies to the data stack, except the interp.4th version

exec that checks if the word is an offset

repeat-frame does need to find a begin-frame or the start of the word.

Does need a limit on stack-find. Add repeat-word?

interp/cross needs a defined?

Review src/lib/linux types to ensure they’re right. file-stat64 and timespec may have more padding.

qemu-arm on my desktop crashes when handling a signal. ffi-callback’s

qemu-arm on my desktop crashes when handling a signal. ffi-callback’s

seem to be doing misaligend ldr-pc. patch-ldr-pc! might be doing the calculation wrong.

Building from Bash is having problems with compiling parent-frame.

December 23

Colon definitions lack a size.

Consolidate stack inits into a function in the runner.

Compiled in tty

Needs constants defined in the interp and out dictionaries: output constants would overlap with builder constants in top level. MVP: Load linux.4th before cross.4th, escaped strings and tty-img[ available in the builder Builder needs abilities to load files pre-runner, post-runner, and pre-cross. Builder could use a single option with a value to flag runner, interp, and cross libraries. north/words needs immediates loaded prior to the runner redefines def, or a way to switch between system and output mode / dictionaries.

Backported the needed TTY functions.

Compiled in core

Working binary

north/words has immediates that need to be used during build

at-start initializer function list

CASE when compiled in failed the tests

Needs:

" src/lib/case.4th" load
core-init
alias> defconst> const>
" src/demos/tty/drawing.4th" load
color-init

null? that leaves argument

Add bracketed word lists to be used by defcol and def.

def fn s[ hello world ] fn[ swap write-line ] map-seqn end

NORTH-COMPILE-TIME -> cross-compiling?

Using defined? allows undefined symbols to be safely used.

Structures

Compile into binary

Usage when using builder / cross compiler

Include into the builder

Accessible while building

Copied and accessible in built code

Actually copying fields at the end of the build is sounding best while keeping byte size up to date. struct: creates system structband an empty struct with associated word. field:, inherits: and create-field functions add to system. End of build: Structs get updated, fields copied, Startup: traverse all instances and add cs to pointers?

Usage when compiled:

Builtin structs need pointer offseting

Interpreter defined structs use pointers

print-instance is CS offset aware.

November

Rename offset32 to something like literal+cs or cs+int32? Then offset is free for relative pointer literals: eip + literal. eip+int32?

Cross compiled structures

Types need to be output AND available to the compiler.

Type and structure accessors need to be output and available too.

Field immediates need to be available to the cross compiler and may need variants.

Initialized variables with an instance

A toplevel set of words to enter and exit the interp and cross compile contexts?

Dictionary list

TTY, socket, signal polling & input

Loaded / compiled files list; require and include?

load-core needs less use if it’s compiled in. Actually crashes if core is already loaded.

Interp command line args

files…

list of files

-e

eval string

-i

always prompt

-D var=value

set var to value before any interpreting; may need a type indicator

-D \[data|return\]-stack=number

stack sizes, location

-v

verbosity

-d

debug; may duplicate the above?

-I

add search path

tty-img[ breaks github browsing: encode?

number-type function to set what numeric type [-+*/%] operate on

One use is trig functions for float32 and float64. Another is using the interpreter as a calculator.

September!

Pi Zero 1:

Has no thumb2 so no coprocessor, no float. Build included lib/math/float32.4th with constants computed using floats. Add hardfloat, softfloat, and nofloat to the platform string? A features list supplied to the builder? Runtime detection of features? FPU? Thumb 1 or 2? Division?

runner/imports.4th crashed a bootstrap to static build. > stage1 checked worked around.

TTY Buffer with Unicode

Buffer cells need to have a larger char field. Should have an indication and option to the terminal’s encoding. Internally utf32 will be used. No need to encode for utf8 if the terminal is utf32.

No way to call foreign function pointers without making a word.

Cross compiling

Move boot/cross.4th into src/cross/interp.4th? src/cross/words/interp.4th? src/cross/interp/words.4th?

Output cell-size: Use out-cell-size in cross compiling and other ouput words. out-op-size could replace -op-size too.

Use ,cell instead of ,uint32 to make cross words more portable. ,out-cell?

Thumb and x86 assemblers need to built into the builder.

Placing each in separate dictionaries could work. defop/endop could load/unload could work for all but macros. Builder adds those words?

Have a (super) lite version of the runner and interpreter.

Only cell sized math. No floats. Minimal syscalls. No debugging aids. Barely able to load-core. A build option to strip unused words? Same words as SectorForth?

TTY

input layered on top of a reader’s buffering and function pointers

input w/ nonblocking support: prior state saved and continuable

Output too? Buffered output: dumped out in the select loop when ready?

fully updating TTY code from old North

No aliases. Normalized vocab.

using readeval

usable in binaries

Binary self verification

Hashing

SHA

sha-224, 512, etc.

SHA-256

Internally: FFI imports need relocs out of the code segment

Calling math-init patches arithmetic words.

Signature

ECC or RSA?

Big integers

Key storage

Standards may require a full ASN.1 stack.

August

big integers

int64 file organization

parse-int for int64

int64 literal words

defining immediates in binary

Three sets of immediates:

• interpreter: top level, interpretable, used in evaluated defs
• cross compiling: interpretable, only used when [cross] compiling
• output: compiled into binary, listed in binary’s immediates.

structs in binary

Defines constants and immediates needed during compilation, and generates accessors needed in compiled output.

More dictionary meta data: files loaded, definition source location

process.4th

function to start with a provided function

execve wrapper to run system commands: needs to build/copy env and an argv array of strings

Julyzz

self contained binaries

boot/core and friends

immediates

structs

better dictionary separation by switching modes & dictionaries

clock, raycaster

eliminate aliases

standalone builder w/ files on command line

actual compilation to machine code

sized sequences for code fields

copy code field, may need a trampoline field or every interpreted word needs a copied code sequence

define code to translate direct threads

Dictionaries

Remove dedicated register

Use data var.

Association list

Ops with doop code, assembly data fields?

Call code field that then jumps to data.

Entries store executable function objects

Reorder dict-map arguments to make fn last.

Delay writing out until the end of building?

error handler, catch and throw

<=June?

struct fields don’t resolve right w/ b and b1 fields.

Fixed?

swap tty-cursor-to’s arguments to row, column

cross-lookup in bash takes one argument, interp’s version takes two.

cpio file format as arguments

float tests

uint64

byte order differs from stack / argument and poked memory order

Little endian puts LSB at the lower address. Stack ordering has LSB at the higher address. But byte order in code needs to be consistent on big and little endian systems, which may need 64 bit support in the integer reader instead of faking it.

core.4th needs a split to allow inclusion in binary

Sooner than later

current-tty and standard-tty that opens /dev/tty for IO

When TTY output to a pipe is desired?

needs writes that take an fd

reads need fd too

Crashes with literal int32 123

s” places the string onto the data stack polluting the binary. Special interp version for defproper?

[#A] structures

[#A] variables with data on stack or data segment. initialized on load

[#B] ELF exports

[#A] Build improvement

Multiple targets: thumb 1 & 2, a32, a64, x86, bacaw; android, linux, baremetal; static, dynamic

Dependencies: only execute/scan for load

Local variables

North porting

[#B] Error handler

[#C] Zero copy reading

Would only work when the token does not span reads.

Compiling to assembly

egl / gles & TTY drawing

Vulkan on Android doesn’t report any devices to 32 bit code.

bare metal

Pi Zero / 2

Pi 3

M0 / micro:bit

Ports

x86

bacaw

quine

The ability to dump the program to source code into a loadable and buildable format.

Disasm

integrated into dictionary dump

Sized sequences for code fields

immediates

Find equivalent words to add immediate and/or immediate-as after the definition.

hexadecimal 0x prefixes

cstring needs to not appear before string literals

Reconstruction of immediate words

IF/ELSE/THEN

CASE ENDCASE

Non-cell data values

Arrays, strings, lists, (function) pointers

[#A] builder binary

Needs immediate dictionary writing and overrides.

Command line arguments

Standard Forth

Fully standard list of words

Comma & period words

Standard Forth uses these for stream output. Switch to < or > like standard stack ops?

byte data

,ins breaks the rule on ,word and .word.

asm ops

CASE

CASE
  N OF ... ENDOF
  else...
ENDCASE

Loops

begin ... condition until
begin ... while condition... repeat
max init do ... loop
leave
return
+loop

Misc

0sp - zero stack to init rot a b c – b c a -rot a b c – c a b pick -> 1 + overn nip -> swap drop tuck a b – b a b

lshift rshift arshift

include file : loads file include? file : loads file if it’s not already loaded forget file : unload the file’s definitions (a word to free and forget?) anew : called when entering a new file for bookkeeping for forget. ? +!

struct

struct: name
  type field: name
  ...

defer

Executable words that can be rebound with IS.

defer motd
' hello is motd
motd ( calls hello )
what's motd ( -> ' hello )

[IF]

[IF] and other bracketed conditions behave like #if in C.

Remove brackets on toplevel use.

locals

{ arg1 arg0 | local0 – result }

String readers have length limit of token-buffer-max. Could/should read more.

Full cpio archive concatenated onto binary.

needs memory decoding instead of file reads

Use the reader.

And/or cpio header file offset argument

cpio encoder

compressed?

Postpone lookup with and without immediates

Using ' in a definition should be like literal or more like pointer?

#BEGIN_SRC

' hello literal hey assert-equals

#END_SRC

Makefile cross compile support

Makefile needs TARGET and HOST documented

Makefile detection for HOST defaulted to aarch64 forcing use of qemu.

Runner needs targeting

For op specific data: if the word is in R1, can that be used to address the data field for…? perhaps not for init.

dynamic linking

GNU

.dynstr section header for the dynamic string table

find what’s keeping relocations from using actual symbol addresses

Android / GNU switch

abs-int or int-abs?

runner ops

exec -> exec-cs-offset, interp/boot/cross.4th aliases to exec-cs

call ops and return to next

variables on stack

array index interpreter

array of words common with x86 to boot strap a full list of words

Pi Zero

Lacks thumb2 and therefore division and coprocessor ops.

Start with software divide

Swap to/from HW & SW

Detect thumb2 in HWCAPS on start

trap SIGILL

A32 coprocessor ops

Use aarch32 code to make coprocessor calls?

Do new branch ops work?

compile loop:

relocate calls and pointers but not data literals

immediate / compiling words & dictionary

compiler lookup

compile with different dictionaries

Base offset for word addresses

Reader

Rewrite from bash to Forth?

Reuse reader from North Core? read-byte level.

Call frames, stack & data pointer math

Split into buffered reader and tokenizer

Writing

ddump to binary file

initial code / header & footer

ELF32 files

ELF64 files

Blobs for Bacaw

EXE files

extract strings from data into section

symbol table section

Data RO and BSS sections

Defining words

Compiled words: create & def -> :

Compiler words: :

Immediates: immediate

Debugger

function call tracing

breakpoints

watch points

memory / variable watches

execution stepping

exception and signal trapping

stack printing, back traces

resuming execution

Assemblers

Two passes with labels

New-lines write instructions; one per line

Binary lacks features to compile a bare bones program.

Seg faults

constants

load-core features

ISAs

Bacaw

x86

athumb

Branching and return in Thumb; to call ops in ops and call threading

Thumb Assembler meta words: mov checks arg range

aarch32

Status register and coprocessor ops

More op coverage

Port from bash to North

aarch64

assembler

ELF64

xtensa

jumps & loops

Amounts in op-size instead of bytes.

relative jumps

returns

IF immediate to count offset

read strings properly in load, using immediates

load needs to be callable from definitions.

Needs to interpret input when called while not reading additional input.

Building needs to allow different program inclusions

Returns that eat frame args and shift return values

Have return1-n now.

#+BEGIN def f ( x y z – a b ) a b returns 3 2 end

def f ( x y z – a b ) [ a b ] return end

[ x y z ] f => [ a b ]

4 1 2 + dup 3 overn f

#+END

Building

Need to better handle targets and loading their sources. Too much duplication. Pass sources in as args from Makefile? Every file requires what it needs?

Loading the assembler words into a Bash generated binary vs. catting them in and dumping?

Words needed for catting:

Cat in the better compiler. Cat in just the assembler.

Top level

const> var> load

Functions

Creating dictionary entries: make-dict-entry create dict-entry accessors compiling-read with immediates: reuse comments & strings string appending

Dictionary entries that are and have real pointers. All their fields need CS added. Threads too: offset & indirect. Data stack: relative or absolute?

argc/argv

getopt like function

Separate ops and definitions

Separate bash specific defs from the general

Variables

Move to own segment

Flip int-sub args in runner

Use just ‘end’ instead of ‘end.*’?

defcol & def can share more code

Reader return: drop for negative lengths on reads subsequent to failure

compiling-read with empty defs, defcol with single element

concat-seq down-stack uses revmap-stack? stack-find?

16 bit op codes: needs int32, literal, etc. to be immediates that write proper sized bytes to op sequence.

make-noname: call a function with predetermined arguments like `equals?` with one argument.

Rename to curry?

[#A] Dictionary entry code value: has to point to real code?

Would be nice to have colon definitions as code words.

Variable data allocated on init, value outside the dictionary.

Lisp style dictionary: assoc list of functions

Remove unasked output

Tail call optimizations

Proper colon defs

Framed calls

Reader needs its own token buffer; no need to return last char/status, negative happens next read

create> should return the entry, does-col should use it

Bash specifically.

load: reader needs data slot and finalizer, and a stack of readers

stage1

Hexadecimal numbers for input

Load or cat?

load needs file opening and reading with a reader stack.

definitions writen to the data stack

definitions with code reuse

definition definability for macros

String concatenation: ++

Standard wording

c” returns a 2 string

Returning from colon def vs frame’s return

return stack words

map-string good candidate for cons on stack safety.

Dictionary lookup with word lists / modules

`word-list word` where `word-list` is an immediate that looks `word` up in the named word list.

import for use in current module

brings in name spacing: what word lists to search when compiling

in-package & export/public & import interplays

Lambda / Code blocks & lists: use [ ] to delineate

To cross compile: need const>, var>, get-word, set-word, IF/ELSE/THEN

ELF32

Exports

ELF dynamic linking of imports

Proper symbol flags

Library loading

Function imports

Add symbols only once

Dynamically linked variable

ELF .o files with symbol table

ELF symbol table of imports

proper DT_HASH

DT_GNU_HASH

Runner’s jumps by op offsets

A .symtab is needed to link as a shared object.

Compile list of words into list of assembly calls.

North

Missing/stubbed words

Move to defcol, def, “:” convention.

Syscalls

mmap memory

data stack using brk

mmap file

Zero copy reads with mmap / from strings; no copy if no more data is read when reading a token

mmap output and set data stack to write to a file.

Catch segfaults & other errors

Spawn a thread

fork & exec

Testing

Move tests to assert-equals

Test DSL: group into suites, setup and teardown, run in child process?

quit needs to reset dict in case words are on the stack

Variables stored outside dictionary.

Move stack to top-frame and reinit everything.

remove early uses of R3 to track calls and returns

Organization

bash forth

compiler

assemblers

lib

stage1: thumb forth

interpreter

compiler

runner

thumb forth + assembler

stage2

compiler

code fields need to point at words, not code

Tension between output offsets and pointers; dhere is an offset or translate when needed?

null (last dictionary) lets lookup return a null, default object.

string readers

” returns a pointer & length when bash cross compiles. ” returns just a pointer in interp Maintaining the length some where is good. s” c” tmp” d” ; some only make sense when interpreting at top level Touches words that take pointer or a pointer/length pair.

Currently

fn	TL storage	def storage	returns
c”	stack		chars length
d”	data	data	pointer length
s”	stack	data	pointer length
tmp”	buffer		pointer length
“	??	??	bash: pointer
			cross: pointer length
			interp: pointer!

Desired

fn	TL storage	def storage	returns
c”	stack		chars length
d”	data	data	pointer length
s”	stack	data	pointer length
tmp”	buffer		pointer length
“	stack	data	pointer

load from strings

save ELF runtime image

Write code segment, data segment, and stack to an ELF blob. Each part needs a segment and program headers to load to same memory location. Dynamic linking would move these.

Needs .data size

Stack will need to be made position independent and reindexed on load.

Quine: dump loadable source code

include textual source in binary? Could provide hints about immediates used.

generic next that calls a function to get the next word depending on source or flavor

To unify interpretation of tokens and indirect threads.

immediates

check if literals and pointers are words

error handling that quits and/or starts a new interpreter loop

Make output functions take an fd or stream argument.

Eliminate needless padding

Zero needed at end of definitions for decompile. [Data] segment needs to be aligned at 4096 bytes.

map-seq, map-seqn: prefer lengths over terminator at end

back port compiling-read

DRY cross compiling code

out-off’ should be ’ but using the compiling-dict; likewise with [‘]

dry up with comp’ immediated as ’ to use compiling-dict.

op sized jumps instead of bytes

move defining/*-boot files to interp/boot/defining, or put arch specific files under a cross/${arch}/

Towards Lisp

Dictionary as argument

to compiler

to interpreter

Dictionary list & first class functions

Types

Structures

Sequences

Garbage collection

Pointers that point down the stack are bad.

The locals…

Needs to collect from a set of roots:

values, pointers, sequences, offset code, live frames Pointers to sequences of unknown size are one problem.

after loop

Exports, symbol table

builder executable that’s passed files to build

immediate list built for executable

flags to toggle static/dynamic, linux/android, elf32/64

sigill trap to detect cpu ops

x86

Interpreted IF & UNLESS in Bash could not be postponed

Called ops & LR

Calling ops like any other procedure makes subroutine call threading easy.

LR only needs to be pushed if an op makes a call.

Returns are popping into PC

For an op without calls just a mov PC, LR.

Ops can get back to next if next sets LR.

When does next exit??

Needs an explicit BYE. exit gets out of a thread, restoring eip.

Where LR should be saved and restored? Need a foreign interface to call in.

Only save LR with an outer-exec? Exit by clearing stack and setting PC. Or exit up all the way.

Mixing threading types? Puts responsibility on enter and exit to return to the right procedure caller.

Requires defcol to factor in a multiple valued return record. swap-call-frame

EIP, LR

Assembling Call threading

Ops & Compiled definitions

branch-link possible jump table

Interpreted words

Inline exec

Should be the same so runtime changes can happen.

Numbers

Prefixed hexadecimal output: 0xNN

Arbitrary base output

Floating point input

Floating point output

overflows integers and fraction needs zero padding

exponent: NNeXX

Floating point constants: pi, e, +/- infinity, nan, +/- 0

32 bit

64 bit

Math

log2, logn

integers

optimize by splitting

floats

exp, pow, sqrt

integers

floats

optimize

exp has a trick reusing results, powers of two can bit shift

trigonometry: sin, cos, tan, asin, acos, atan

further test and verification

circular

hyperbolic

float64

big integers (> 64 bits)

arithmetic

logic

comparisons

writers

conversions

fixed point w/ user specified precision

Thoughts

Cross compiling

Top level interpreter and cross compiling ideally use the same vocabulary. Need to be able to enter and exit the cross compiling vocabulary. Likewise with the assemblers. Constants should appear in both environments. Compiling code should be able to alter the compiling environment.

Vocabulary

Immediates

IF ELSE THEN CASE OF ENDOF ENDCASE s” ” ’ s[

Literalizers

Dictionary ops

create create> lookup drop-dict

Defining words

var> const> defcol def : immediate immediate-as string-const> symbol>

Transitioning

Prefixes alone?

Used every where. Nice to be optional.

Dictionary of word lists?

Combine multiple sets. Mix and match on a per file basis?

More dictionary ops: Mark/forget/cut/append?

Drop in primitives for modules.

Modules?

Saved environments

Store the dictionaries in a structure. Save and switch to them at will. Bit like a fork. Marks with dict and idict?

Modules

Can be mixed together. Prefixed Essentially a list of word lists. Default user to TopLevel. Integration with files? Lexical scoping Still doesn’t handle the mixed code segments.

module TopLevel endmodule

module A module B def sq arg0 arg0 * 1 return1-n end end

module C def sq arg1 arg1 * arg0 arg0 * 2 return2-n end end end

4 A :: B :: sq

A :: B include 5 sq

module D A :: B include

def mag arg1 sq arg0 sq + 2 return1-n end end

A :: C module E arg0 include def mag arg1 sq arg0 sq + 2 return1-n end end

module F ’ D :: mag import-as> mag-int end

def syntax

Current

var> const> alias> defcol => defcolon def :

General def and lists

Scheme style symbol table

Dictionary

dict is an assoc list

values are function objects

Head points to a Type that has a caller attribute. Tail points to the definition sequence.

Sequences

[ exprs… ] => sequence ‘[ exprs… ] => sequence of resolved, but unexecuted, symbols

Variables

def name value def name s[ exprs… ]

Colon definitions

def name [ exprs… ] def name colon[ exprs… ]

Framed colon definitions

def name fun[ exprs… ] def name begin[ exprs… ] def name fun( args… ) exprs… end

def name fun exprs… end def name begin exprs… end def name fun( args… )[ exprs… ]

def name [ args… ] do exprs… end def name [ args… ] { exprs… }

Cross compiling reads

Need to restore state. Globals make this tough, but compiler object with output stack, immediates, and words can handle that.

Optimizations

Constants can be immediates

Inlining

To assembly call threading

repeated call sequences that have no side effects and return the same values each call can set a generated binding.

Arithmetic between constants

Division and multiply by powers of two

Tail calls

function that can call defs and ops w/o pushing return address or creating frames, name it exec?

dict register -> this pointer

Calls in a definition are indexed from the register. Dictionary specified at compile time by specifying a type.

Next words

Current

func> tokens+ func: tokens+

Possible

Difference in the interpretation of what gets read and returned.

Compiling state with lookup and immediates.

func[ tokens… ] func [ tokens… ]

Reads in a colon definition.

less than compiling. With immediates?

func< (types|atoms)+ > func < (types|atoms)+ >

Needed for creating generic types via generator functions. Interpretation semantics: at minimum, words looked up, value placed on stack. ‘>’ completes the read with word values on stack.

Other syntaxes

Lists

func( tokens+ ) func{ tokens+ }

Immediates?

Strings

func” chars*” func/ chars*/

Algorithms

Easy(?) enough to implement algorithms to securely and efficiently interact with the world.

Data

b-tree

sorting

Crypto

Hashes

SHA

Symetric ciphers

AES

Asymetric

ECC

RSA

Compression

Inflate

LZ4

Protocols

HTTP(S)

<=1.1

>=3

SSH

Formats

JSON

XML

Distribution archive: cpio.gz?

Everything is a sequence

A sequence: ptr -> type, length, *data -> memory Even functions. Arguments are too. Calls would push the FP, return address, and 2 plus the number of arguments, and then the new frame pointer.

In the source

#+NAME todos

grep --exclude \*~ -Hn -E "todo|fixme" -r ./src | sed -E -e 's/(.+):([0-9]+):(.*)\( +(todo.*|fixme.*) +(.*) +\)/\4 \5 [[file:\1::\2]]/g' -e 's:todo:TODO:g' -e 's:fixme:FIXME:g' | tee >(wc -l)