the compiler

\ copyright © 2006 the osmosian order (3040)

\ firstparam=esp+4/ebp+8, secondparam=esp+8/ebp+12, etc...

an abort message is a string.

to abort with a string:
  if the compiler's abort flag is set, exit.
  set the compiler's abort flag.
  put the string into the compiler's abort message.

to abort with a string and a byte pointer:
  if the compiler's abort flag is set, exit.
  set the compiler's abort flag.
  put the string into the compiler's abort message.
  find the compiler's abort path and the compiler's abort row# given the byte pointer.
  if the compiler's abort path is blank, exit.
  extract a file name from the compiler's abort path.
  prepend "Error in " then the file name then ". " to the compiler's abort message.

to abort with a string and a rider:
  if the rider's token is not blank, abort with the string and the rider's token's first; exit.
  abort with the string and the rider's source's last.

to add the allocate and deallocate and finalize and destroy routines:
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  add the finalize routine for the type.
  add the allocate routine for the type.
  add the deallocate routine for the type.
  add the destroy routine for the type.
  repeat.

to add the allocate routine for a type:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  if the type cannot be reduced to "pointer", exit.
  if the type's target type is nil, exit.
  add a routine to the routines given nil.
  append "allocate memory for a " then the type's name to the routine's header string.
  append "assign the " then the type's name then " given " to the routine's body string.
  append the type's target type's length then "." to the routine's body string.
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add and compile the initialize before run and run and finalize after run routine:
  if the compiler's abort flag is set, exit.
  add a routine to the routines given nil.
  append "~initialize before run and run and finalize after run" to the routine's header string.
  append "initialize before run. " to the routine's body string.
  append the global initializers to the routine's body string.
  append "run. " to the routine's body string.
  append the global finalizers to the routine's body string.
  append "finalize after run. " to the routine's body string.
  append "call ""kernel32.dll"" ""ExitProcess"" with 0. " to the routine's body string.
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.
  compile the body of the routine.

to add a built-in type given a name and a plural name and a length:
  add the built-in type to the types given the name and the plural name and the name.
  put the length into the built-in type's length.
  put the built-in type into the built-in type's base type.
  index the built-in type.

to add the built-in types:
  add a built-in type given "byte" and "bytes" and 1.
  add another built-in type given "record" and "records" and 0.

to add the deallocate routine for a type:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  if the type cannot be reduced to "pointer", exit.
  if the type's target type is nil, exit.
  add a routine to the routines given nil.
  append "deallocate a " then the type's name to the routine's header string.
  append "if the " then the type's name then " is nil, exit. " to the routine's body string.
  if the type's target type should be finalized, append "~finalize the " then the type's name then "'s target. " to the routine's body string.
  append "unassign the " then the type's name then "." to the routine's body string.
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add the destroy routine for a type:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  if the type should not be forgotten, exit.
  if the type can be reduced to "things", add the destroy routine for the type (things); exit.
  if the type can be reduced to "pointer", add the destroy routine for the type (pointer); exit.

to add the destroy routine for a type (pointer):
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  put "destroy [" then the type's name then "]" into a moniker.
  if the moniker is in the routine index, exit.
  add a routine to the routines given nil.
  append "destroy a " then the type's name to the routine's header string.
  append "if the " then the type's name then " is nil, exit. " to the routine's body string.
  if the type's target type can be reduced to "pointer", append "destroy the " then the type's name then "'s target. " to the routine's body string.
  if the type's target type can be reduced to "things", append "destroy the " then the type's name then "'s target. " to the routine's body string.
  loop.
  get a field from the type's target type's fields.
  if the field is nil, break.
  if the field's reference flag is set, repeat.
  if the field's type should not be forgotten, repeat.
  append "destroy the " then the type's name then "'s " then the field's name then ". " to the routine's body string.
  repeat.
  append "deallocate the " then the type's name then ". " to the routine's body string.
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add the destroy routine for a type (things):
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  if the type's fields' first is nil, abort with "Internal error - add the forget routine for a type (things)"; exit.
  if the type's fields' first's type is nil, abort with "Internal error 2 - add the forget routine for a type (things)"; exit.
  put "destroy [" then the type's name then "]" into a moniker.
  if the moniker is in the routine index, exit.
  add a routine to the routines given nil.
  append "destroy a " then the type's name to the routine's header string.
  append "if the " then the type's name then "'s first is nil, exit. " to the routine's body string.
  put the type's fields' first's type's name into a name.
  append "put the " then the type's name then "'s first into a " then the name then ". " to the routine's body string.
  append "remove the " then the name then " from the " then the type's name then ". " to the routine's body string.
  append "destroy the " then the name then ". " to the routine's body string.
  append "repeat. " to the routine's body string.
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add an entry to some imports given an import name and an entry name:
  find an import given the import name.
  if the import is nil, add the import to the imports given the import name.
  find the entry given the entry name and the import's entries.
  if the entry is not nil, exit.
  create the entry.
  append the entry to the import's entries.
  put the entry name into the entry's name.

to add a field to some fields given a name and a nickname and a type name and a reference flag:
  add the field to the fields given "field" and nil.
  put the name into the field's name.
  put the nickname into the field's nickname.
  put the type name into the field's type name.
  put the reference flag into the field's reference flag.

to add the finalize routine for a type:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  if the type should not be finalized, exit.
  if the type's name is "string", add the finalize routine for the type (string); exit.
  if the type can be reduced to "string", exit. \ prevents generation of finalizer for derived string types
  add the finalize routine for the type (record).

to add the finalize routine for a type (record):
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  add a routine to the routines given nil.
  append "~finalize a " then the type's name to the routine's header string.
  append "intel $50. " to the routine's body string. \ push eax
  loop.
  get a field from the type's fields.
  if the field is nil, break.
  if the field's type should not be finalized, repeat.
  append "~finalize the " then the type's name then "'s " then the field's name then ". " to the routine's body string.
  repeat.
  append "intel $58." to the routine's body string. \ pop eax
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add the finalize routine for a type (string):
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  add a routine to the routines given nil.
  append "~finalize a " then the type's name to the routine's header string.
  append "intel $50. " to the routine's body string. \ push eax
  append "unassign the string's first. " to the routine's body string.
  append "intel $58." to the routine's body string. \ pop eax
  slap the routine's routine header on the routine's header string.
  slap the routine's routine body on the routine's body string.
  compile the header of the routine.

to add a fragment given a tag:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.

to add a fragment given a tag and an entry:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.
  put the entry into the fragment's entry.

to add a fragment given a tag and a routine:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.
  put the routine into the fragment's routine.
  compile the body of the routine.

to add a fragment given a tag and a variable:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.
  put the variable into the fragment's variable.
  set the compiled flag in the variable.

to add a fragment given a tag and a variable and another variable:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.
  put the variable into the fragment's variable.
  put the other variable into the fragment's other variable.
  set the compiled flag in the variable.
  set the compiled flag in the other variable.

to add a fragment given a tag and a variable and a number:
  if the current routine is nil, void the fragment; exit.
  create the fragment given the tag.
  append the fragment to the current routine's fragments.
  put the variable into the fragment's variable.
  put the number into the fragment's number.
  set the compiled flag in the variable.

to add an import to some imports given an import name:
  create the import.
  append the import to the imports.
  put the import name into the import's name.

to add an intermediate given a type name and a locus:
  if the current routine is nil, void the intermediate; exit.
  add the intermediate to the current routine's locals given "local" and the locus.
  generate the intermediate's name given "~I".
  put the type name into the intermediate's type name.
  resolve the intermediate.

to add a literal to some variables given a locus:
  add the literal as a variable to the variables given "literal" and the locus.
  generate the literal's name given "~L".

to add a monikette to some monikettes given an expression:
  create the monikette.
  append the monikette to the monikettes.
  put the expression's phrase into the monikette's string.
  put the expression's variable into the monikette's variable.
  if the expression's variable is not nil, put the expression's type into the monikette's type.

to add a monikette to some monikettes given a string:
  create the monikette.
  append the monikette to the monikettes.
  \ from/given/with/using
  if the string is "from", put "from/given/with/using" into the monikette's string; exit.
  if the string is "given", put "from/given/with/using" into the monikette's string; exit.
  if the string is "with", put "from/given/with/using" into the monikette's string; exit.
  if the string is "using", put "from/given/with/using" into the monikette's string; exit.
  \ in/into/to
  if the string is "in", put "in/into/to" into the monikette's string; exit.
  if the string is "into", put "in/into/to" into the monikette's string; exit.
  if the string is "to", put "in/into/to" into the monikette's string; exit.
  \ is/are
  if the string is "are", put "is/are" into the monikette's string; exit.
  if the string is "is", put "is/are" into the monikette's string; exit.
  \ aren't/isn't
  if the string is "isn't", put "is/aren't" into the monikette's string; exit.
  if the string is "aren't", put "is/aren't" into the monikette's string; exit.
  \ other
  put the string into the monikette's string.

to add a monikette to some monikettes given a type:
  create the monikette.
  append the monikette to the monikettes. 
  put the type into the monikette's type.

to add push fragments given some monikettes:
  if the current routine is nil, exit.
  loop.
  get a monikette from the monikettes (backwards).
  if the monikette is nil, exit.
  if the monikette's variable is nil, repeat.
  if the monikette's current substring is not blank, repeat.
  if the monikette's current type is nil, repeat.
  add a fragment given the push address tag and the monikette's variable.
  repeat.

to add the put or convert fragments given a variable and another variable and a locus:
  add a fragment given the push address tag and the other variable.
  add another fragment given the push address tag and the variable.
  find a routine given "put" and the variable's type and "into" and the other variable's type.
  if the routine is nil, find the routine given "convert" and the variable's type and "to" and the other variable's type.
  if the routine is not nil, add a third fragment given the call internal tag and the routine; exit.
  \ error message
  add a monikette to some monikettes given "put/convert".
  add another monikette to the monikettes given the variable's type.
  add a third monikette to the monikettes given "into/to".
  add a fourth monikette to the monikettes given the other variable's type.
  convert the monikettes to a moniker.
  destroy the monikettes.
  abort with "I don't know how to '" then the moniker then "'." and the locus.

to add a routine to some routines given a locus:
  create the routine.
  append the routine to the routines.
  put the locus into the routine's locus.

to add a scratch given a type name and a locus:
  if the current routine is nil, void the scratch; exit.
  add the scratch to the current routine's locals given "scratch" and the locus.
  generate the scratch's name given "~S".
  put the type name into the scratch's type name.
  resolve the scratch.

to add several fragments given a string and a variable and another string and another variable and a locus:
  add a fragment given the push address tag and the other variable.
  add another fragment given the push address tag and the variable.
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the variable's type.
  add a third monikette to the monikettes given the other string.
  add a fourth monikette to the monikettes given the other variable's type.
  find a routine given the monikettes.
  if the routine is nil, convert the monikettes to a moniker.
  destroy the monikettes.
  if the routine is nil, abort with "I don't know how to '" then the moniker then "'." and the locus; exit.
  add a third fragment given the call internal tag and the routine.

to add several fragments given a string and a variable and another string and another variable and a third string and a third variable and a byte pointer:
  add a fragment given the push address tag and the third variable.
  add another fragment given the push address tag and the other variable.
  add a third fragment given the push address tag and the variable.
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the variable's type.
  add a third monikette to the monikettes given the other string.
  add a fourth monikette to the monikettes given the other variable's type.
  add a fifth monikette to the monikettes given the third string.
  add a sixth monikette to the monikettes given the third variable's type.
  find a routine given the monikettes.
  if the routine is nil, convert the monikettes to a moniker.
  destroy the monikettes.
  if the routine is nil, abort with "I don't know how to '" then the moniker then "'." and the byte pointer; exit.
  add a fourth fragment given the call internal tag and the routine.

to add a source file to some source files given a path:
  create the source file.
  append the source file to the source files.
  put the path into the source file's path.

to add two fragments given a string and a variable and a locus:
  add a fragment given the push address tag and the variable.
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the variable's type.
  find a routine given the monikettes.
  if the routine is nil, convert the monikettes to a moniker.
  destroy the monikettes.
  if the routine is nil, abort with "I don't know how to '" then the moniker then "'." and the locus; exit.
  add another fragment given the call internal tag and the routine.

to add a type to some types given a locus:
  create the type.
  append the type to the types.
  put the locus into the type's locus.

to add a type to some types given a name and a plural name and a base name:
 add the type to the types given the name and the plural name and the base name and nil.

to add a type to some types given a name and a plural name and a base name and a locus:
  create the type.
  append the type to the types.
  put the locus into the type's locus.
  put the name into the type's name.
  put the plural name into the type's plural name.
  put the base name into the type's base name.

to add a variable to some variables given a kind and a locus:
  create the variable given the kind.
  append the variable to the variables.
  put the locus into the variable's locus.

the adding built-in memory routines timer is a timer.

the adding built-in startup routine timer is a timer.

to address some entries:
  get an entry from the entries.
  if the entry is nil, exit.
  address the entry.
  repeat.

to address an entry:
  put the current name address into the entry's name address.
  put the entry's name's length plus 3 into a number.
  round the number up to the nearest multiple of 2.
  add the number to the current name address.
  put the current thunk address into the entry's thunk address.
  put the image base plus the current thunk address into the entry's address.
  add 4 to the current thunk address.

to address a fragment given an address:
  if the compiler's abort flag is set, exit.
  if the fragment is nil, exit.
  put the image base plus the address into the fragment's address.
  if the fragment's tag is the push address tag, add 7 to the address; exit.
  if the fragment's tag is the call internal tag, add 5 to the address; exit.
  if the fragment's tag is the load address tag, add 12 to the address; exit.
  if the fragment's tag is the increment tag, add 10 to the address; exit.
  if the fragment's tag is the dereference tag, add 14 to the address; exit.
  if the fragment's tag is the jump false tag, add 9 to the address; exit.
  if the fragment's tag is the not tag, add 3 to the address; exit.
  if the fragment's tag is the exit tag, add 5 to the address; exit.
  if the fragment's tag is the repeat tag, add 5 to the address; exit.
  if the fragment's tag is the break tag, add 5 to the address; exit.
  if the fragment's tag is the prolog tag, address the fragment given the address (prolog); exit.
  if the fragment's tag is the epilog tag, address the fragment given the address (epilog); exit.
  if the fragment's tag is the intel tag, add the fragment's code's length to the address; exit.
  if the fragment's tag is the push value tag, address the fragment given the address (push value); exit.
  if the fragment's tag is the call external tag, add 6 to the address; exit.
  if the fragment's tag is the load eax tag, add 8 to the address; exit.
  if the fragment's tag is the save eax tag, address the fragment given the address (save eax); exit.
  if the fragment's tag is the call indirect tag, add 8 to the address; exit.
  if the fragment's tag is the routine address tag, add 12 to the address; exit.

to address a fragment given an address (epilog):
  if the current routine's callback flag is set, add 3 to the address.
  add 6 to the address.

to address a fragment given an address (prolog):
  add 3 to the address.
  if the current routine's local size is not 0, add 10 to the address.
  if the current routine's callback flag is set, add 3 to the address.

to address a fragment given an address (push value):
  add 6 to the address.
  if the fragment's variable is nil, abort with "Internal error - address a fragment given an address (push value)"; exit.
  if the fragment's variable's type is nil, abort with "Internal error 2 - address a fragment given an address (push value)"; exit.
  put the fragment's variable's type's length into a length.
  if the length is 4, add 2 to the address; exit.
  if the length is 2, add 3 to the address; exit.
  if the length is 1, add 4 to the address; exit.
  abort with "Internal error 3 - address a fragment given an address (push value)".

to address a fragment given an address (save eax):
  add 6 to the address.
  if the fragment's variable is nil, abort with "Internal error - address a fragment given an address (push value)"; exit.
  if the fragment's variable's type is nil, abort with "Internal error 2 - address a fragment given an address (push value)"; exit.
  put the fragment's variable's type's length into a length.
  if the length is 4, add 2 to the address; exit.
  if the length is 2, add 3 to the address; exit.
  if the length is 1, add 2 to the address; exit.
  abort with "Internal error 3 - address a fragment given an address (push value)".

to address some fragments given an address:
  if the compiler's abort flag is set, exit.
  get a fragment from the fragments.
  if the fragment is nil, exit.
  address the fragment given the address.
  repeat.

to address an import:
  put the current name address into the import's name address.
  put the current header address into the import's header address.
  put the current name address into the import's import header's name memory address.
  put the import's name's length plus 1 into a number.
  round the number up to the nearest multiple of 2.
  add the number to the current name address.
  add an import header's magnitude to the current header address.
  put the current thunk address into the import's import header's first thunk memory address.
  address the import's entries.
  add 4 to the current thunk address.

to address some imports given an address:
  put the address into the current header address.
  put the imports' count into a count.
  add 1 to the count.
  multiply the count by an import header's magnitude.
  put the address plus the count into the current thunk address.
  get another count given the imports (all entries plus markers).
  multiply the other count by 4.
  put the current thunk address plus the other count into the current name address.
  loop.
  get an import from the imports.
  if the import is nil, break.
  address the import.
  repeat.
  put the current name address minus the address into a number.
  add the number to the address.

an address is a number.

to address a routine given an address:
  if the compiler's abort flag is set, exit.
  if the routine is nil, exit.
  if the routine's employs moniker is not blank, exit.
  if the routine's compiled flag is not set, exit.
  put the routine into the current routine.
  put the image base plus the address into the routine's address.
  address the routine's fragments given the address.
  round the address up to the nearest multiple of 4.

to address some routines given an address:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, break.
  address the routine given the address.
  repeat.

to address a variable given an address:
  if the compiler's abort flag is set, exit.
  if the variable is nil, exit.
  if the variable's compiled flag is not set, exit.
  put the image base plus the address into the variable's address.
  add the variable's type's length to the address.
  if the variable's type can be reduced to "string", add the variable's data's length plus 1 to the address.
  round the address up to the nearest multiple of 4.

to address some variables given an address:
  if the compiler's abort flag is set, exit.
  get a variable from the variables.
  if the variable is nil, exit.
  address the variable given the address.
  repeat.

the addressing timer is a timer.

to advance a buffer:
  append the return byte to the buffer.
  append the linefeed byte to the buffer.

to advance a buffer (twice):
  advance the buffer. 
  advance the buffer.

to append an entry to a buffer (with separator):
  if the entry is nil, append "" to the buffer (with separator); exit.
  append the entry's name to the buffer (with separator).

to append a flag to a buffer (with separator):
  convert the flag to a string.
  append the string to the buffer (with separator).

to append the global finalizers to a string:
  get a global from the globals.
  if the global is nil, exit.
  if the global's compiled flag is not set, repeat.
  if the global's type should not be finalized, repeat.
  append "~finalize the " then the global's name then ". " to the string.
  repeat.

to append the global initializers to a string:
  get a global from the globals.
  if the global is nil, exit.
  if the global's literal is nil, repeat.
  if the global's compiled flag is not set, repeat.
  clear a flag.
  append the global's initializer string to the string.
  repeat.

to append a monikette to a moniker:
  if the monikette is nil, exit.
  if the moniker is not blank, append the space byte to the moniker.
  if the monikette's type is not nil, append "[" and the monikette's type's name and "]" to the moniker (fast); exit.
  if the monikette's string is not blank, append the monikette's string to the moniker; exit.

to append a monikette to a moniker (while bubbling):
  if the monikette is nil, exit.
  if the moniker is not blank, append the space byte to the moniker.
  if the monikette's current substring is not blank, append the monikette's current substring to the moniker; exit.
  if the monikette's current type is not nil, append "[" and the monikette's current type's name and "]" to the moniker (fast); exit.

to append a number to a buffer (as hex with separator):
  convert the number to a nibble string.
  append the nibble string to the buffer (with separator).

to append a number to a buffer (with separator):
  convert the number to a string.
  append the string to the buffer (with separator).

to append a ratio to a buffer (with separator):
  convert the ratio to a string.
  append the string to the buffer (with separator).

to append a routine to a buffer (with separator):
  if the routine is nil, append "" to the buffer (with separator); exit.
  append the routine's moniker to the buffer (with separator).

to append a string and another string and a third string to a fourth string (fast):
  put the fourth string's length into a length.
  add the string's length to the length.
  add the other string's length to the length.
  add the third string's length to the length.
  reassign a pointer given the length.
  put the pointer into a byte pointer.
  copy bytes from the fourth string's first to the byte pointer for the fourth string's length.
  add the fourth string's length to the byte pointer.
  copy bytes from the string's first to the byte pointer for the string's length.
  add the string's length to the byte pointer.
  copy bytes from the other string's first to the byte pointer for the other string's length.
  add the other string's length to the byte pointer.
  copy bytes from the third string's first to the byte pointer for the third string's length.
  unassign the fourth string's first.
  put the pointer into the fourth string's first.
  put the pointer plus the length minus 1 into the fourth string's last.

to append a string to a buffer (with separator):
  append the string to the buffer.
  append "/" to the buffer.

to append a tag to a buffer (as a fragment tag string with separator):
  if the tag is the break tag, append "break" to the buffer (with separator); exit.
  if the tag is the call external tag, append "call external" to the buffer (with separator); exit.
  if the tag is the call indirect tag, append "call indirect" to the buffer (with separator); exit.
  if the tag is the call internal tag, append "call internal" to the buffer (with separator); exit.
  if the tag is the dereference tag, append "dereference" to the buffer (with separator); exit.
  if the tag is the end if tag, append "end if" to the buffer (with separator); exit.
  if the tag is the epilog tag, append "epilog" to the buffer (with separator); exit.
  if the tag is the exit tag, append "exit" to the buffer (with separator); exit.
  if the tag is the finalize tag, append "finalize" to the buffer (with separator); exit.
  if the tag is the increment tag, append "increment" to the buffer (with separator); exit.
  if the tag is the intel tag, append "intel" to the buffer (with separator); exit.
  if the tag is the jump false tag, append "jump false" to the buffer (with separator); exit.
  if the tag is the load address tag, append "load address" to the buffer (with separator); exit.
  if the tag is the load eax tag, append "load eax" to the buffer (with separator); exit.
  if the tag is the loop tag, append "loop" to the buffer (with separator); exit.
  if the tag is the not tag, append "not" to the buffer (with separator); exit.
  if the tag is the prolog tag, append "prolog" to the buffer (with separator); exit.
  if the tag is the push address tag, append "push address" to the buffer (with separator); exit.
  if the tag is the push value tag, append "push value" to the buffer (with separator); exit.
  if the tag is the save eax tag, append "save eax" to the buffer (with separator); exit.
  if the tag is the repeat tag, append "repeat" to the buffer (with separator); exit.
  if the tag is the routine address tag, append "routine address" to the buffer (with separator); exit.
  append "?" to the buffer (with separator).

to append a type to a buffer (with separator):
  if the type is nil, append "" to the buffer (with separator); exit.
  append the type's name to the buffer (with separator).

to append a variable to a buffer (with separator):
  if the variable is nil, append "" to the buffer (with separator); exit.
  append the variable's name to the buffer (with separator).

to attach address loading code to a hex string given a variable: \ loads into edx
  if the variable is nil, attach $C7C200000000 to the hex string; exit. \ mov edx,0
  if the variable's kind is "global", attach $C7C2 and the variable's address to the hex string; exit. \ mov edx,the variable's address
  if the variable's kind is "literal", attach $C7C2 and the variable's address to the hex string; exit. \ mov edx,the variable's address
  if the variable's kind is "local", attach $8D95 and the variable's offset to the hex string; exit. \ lea edx,[ebp+the variable's offset]
  if the variable's kind is "scratch", attach $8B95 and the variable's offset to the hex string; exit. \ mov edx,[ebp+the variable's offset]
  if the variable's kind is not "parameter", abort with "Internal error - attach address loading code to a hex string given a variable"; exit.
  if the variable's by-value flag is set, attach $8D95 and the variable's offset to the hex string; exit. \ lea edx,[ebp+the variable's offset]
  attach $8B95 and the variable's offset to the hex string. \ mov edx,[ebp+the variable's offset]

to attach an hex string and an address to a fragment: \ call or jump
  put the address into a number.
  subtract the fragment's address from the number.
  subtract the fragment's code's length from the number.
  subtract the hex string's length from the number.
  subtract 4 from the number.
  attach the hex string and the number to the fragment's code.

to attach a hex string and a number and another hex string to a third hex string:
  append the hex string to the third hex string.
  convert the number to a fourth hex string.
  append the fourth hex string to the third hex string.
  append the other hex string to the third hex string.

to attach a hex string and a number and another number to another hex string:
  append the hex string to the other hex string.
  convert the number to a third hex string.
  append the third hex string to the other hex string.
  convert the other number to a fourth hex string.
  append the fourth hex string to the other hex string.

to attach a hex string and a number to another hex string:
  append the hex string to the other hex string.
  convert the number to a third hex string.
  append the third hex string to the other hex string.

to attach a hex string to another hex string: employ append a string to another string.

to blurt bytes given a pointer and a length and a buffer and an offset:
  put the buffer's first plus the offset into another pointer.
  copy bytes from the pointer to the other pointer for the length.

to blurt a dos header into a buffer:
  blurt bytes given the dos header's whereabouts and the dos header's magnitude and the buffer and 0.

to blurt some entries into a buffer:
  get an entry from the entries.
  if the entry is nil, exit.
  blurt the entry into the buffer.
  repeat.

to blurt an entry into a buffer:
  blurt bytes given the entry's name address's whereabouts and 4 and the buffer and the entry's thunk address.
  put the entry's name address plus 2 into an address.
  blurt the entry's name into the buffer at the address.

to blurt a fragment into a buffer:
  if the fragment's code is blank, exit.
  put the fragment's address minus the image base into an address.
  blurt the fragment's code into the buffer at the address.

to blurt some fragments into a buffer:
  get a fragment from the fragments.
  if the fragment is nil, exit.
  blurt the fragment into the buffer.
  repeat.

to blurt an import into a buffer:
  blurt bytes given the import's import header's whereabouts and the import's import header's magnitude and the buffer and the import's header address.
  blurt the import's name into the buffer at the import's name address.
  blurt the import's entries into the buffer.

to blurt some imports into a buffer:
  get an import from the imports.
  if the import is nil, exit.
  blurt the import into the buffer.
  repeat.

to blurt a pe header into a buffer:
  blurt bytes given the pe header's whereabouts and the pe header's magnitude and the buffer and 256.

to blurt a routine into a buffer:
  if the routine's compiled flag is not set, exit.
  blurt the routine's fragments into the buffer.

to blurt some routines into a buffer:
  get a routine from the routines.
  if the routine is nil, exit.
  blurt the routine into the buffer.
  repeat.

to blurt a string into a buffer at an address:
  blurt bytes given the string's first and the string's length and the buffer and the address.

to blurt a variable into a buffer:
  if the variable's compiled flag is not set, exit.
  if the variable's type can be reduced to "string", blurt the variable into the buffer (as a string); exit.
  put the variable's address minus the image base into an address.
  blurt the variable's data into the buffer at the address.

to blurt a variable into a buffer (as a string):
  put the variable's address minus the image base into an address.
  put the variable's data's length into a length.
  put the address into another address.
  add a prototype string's magnitude to the other address.
  add the image base to the other address.
  put 0 into the prototype string's first.
  put -1 into the prototype string's last.
  if the length is not 0, put the other address into the prototype string's first.
  if the length is not 0, put the prototype string's first plus the length minus 1 into the prototype string's last.
  blurt bytes given the prototype string's whereabouts and the prototype string's magnitude and the buffer and the address.
  add the prototype string's magnitude to the address.
  blurt the variable's data into the buffer at the address.

to blurt some variables into a buffer:
  get a variable from the variables.
  if the variable is nil, exit.
  blurt the variable into the buffer.
  repeat.

a borough has a base address, a length and a size.

the break tag is a tag equal to 1.

to bubble a monikette:
  if the monikette is nil, exit.
  if the monikette's current substring is not blank, clear the monikette's current substring; exit.
  if the monikette's current type is nil, exit.
  if the monikette's current type is any built-in type, put nil into the monikette's current type; exit.
  put the monikette's current type's base type into the monikette's current type.

a built-in type is a type.

to calculate the length of a type:
  if the type is nil, exit.
  if the type's length is not -1, exit.
  calculate the length of the type's base type.
  if the type's fields are empty, put the type's base type's length into the type's length; exit.
  put 0 into the type's length.
  loop.
  if the compiler's abort flag is set, exit.
  get a field from the type's fields.
  if the field is nil, exit.
  if the field's redefinition target name is not blank, repeat.
  calculate the length of the field's type.
  add the field's type's length times the field's count to the type's length.
  repeat.

to calculate the lengths of some types:
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  calculate the length of the type.
  repeat.

to calculate the offsets in a type:
  if the type is nil, exit.
  put 0 into an offset.
  loop.
  if the compiler's abort flag is set, exit.
  get a field from the type's fields.
  if the field is nil, exit.
  if the field's redefinition target name is not blank, repeat.
  put the offset into the field's offset.
  add the field's type's length times the field's count to the offset.
  repeat.

to calculate the offsets in some types:
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  calculate the offsets in the type.
  repeat.

to calculate the redefinition offsets in a type:
  if the type is nil, exit.
  loop.
  if the compiler's abort flag is set, exit.
  get a field from the type's fields.
  if the field is nil, exit.
  if the field's redefinition target name is blank, repeat.
  find another field given the field's redefinition target name and the type's fields.
  if the other field is nil, abort with "Invalid redefine. I can't find the '" then the field's redefinition target name then "' field." and the field's locus; exit.
  put the other field's offset into the field's offset.
  repeat.

to calculate the redefinition offsets in some types:
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  calculate the redefinition offsets in the type.
  repeat.

the calculating timer is a timer.

the call external tag is a tag equal to 2.

the call indirect tag is a tag equal to 3.

the call internal tag is a tag equal to 4.

to check for invalid optional info on a type:
  if the compiler's abort flag is set, exit.
  if the type is nil, exit.
  if the type's target name is not blank, check for invalid optional info on the type (target).
  if the type's fields are not empty, check for invalid optional info on the type (fields).
  if the type's scale is not 0, check for invalid optional info on the type (scale).

to check for invalid optional info on a type (fields):
  if the compiler's abort flag is set, exit.
  if the type cannot be reduced to "record", abort with "Optional 'with' info is only allowed on record types." and the type's locus; exit.

to check for invalid optional info on a type (scale):
  if the compiler's abort flag is set, exit.
  if the type cannot be reduced to "number", abort with "Scales are only allowed on number types." and the type's locus; exit.

to check for invalid optional info on a type (target):
  if the compiler's abort flag is set, exit.
  if the type cannot be reduced to "pointer", abort with "Optional 'to' info is only allowed on pointer types." and the type's locus; exit.

to clear a field term:
  fill bytes with the null byte starting at the field term's whereabouts for the field term's magnitude.

to clear a term:
  void the term's variable.
  clear the term's phrase.

the code borough is a borough.

to compile the bodies of the routines:
  compile the body of the routine called "initialize before run".
  compile the body of the routine called "run".
  compile the body of the routine called "finalize after run".

to compile the body of a routine:
  if the routine is nil, exit.
  if the compiler's abort flag is set, exit.
  if the routine's compiled flag is set, exit.
  set the routine's compiled flag.
  slap a rider on the routine's routine body.
  move the rider (compiler rules).
  if the rider's token is "employ", compile the body of the routine given the rider (employ); exit.
  put the current routine into a saved routine.
  put the routine into the current routine.
  create the routine's nickname index given 101.
  eliminate duplicate nicknames from the routine's parameters given the routine's nickname index.
  compile the body of the routine (prolog).
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, break.
  compile the next statement given the rider.
  repeat.
  compile the body of the routine (epilog).
  put the saved routine into the current routine.

to compile the body of a routine (epilog):
  if the routine is nil, exit.
  if the compiler's abort flag is set, exit.
  add a fragment given the finalize tag.
  loop.
  get a variable from the routine's locals.
  if the variable is nil, break.
  if the variable's kind is "scratch", repeat.
  if the variable's type should not be finalized, repeat.
  add another fragment given the push address tag and the variable.
  find another routine given "~finalize" and the variable's type.
  if the other routine is nil, abort with "Internal error - compile the body of a routine (epilog)"; exit.
  add a third fragment given the call internal tag and the other routine.
  repeat.
  add a fourth fragment given the epilog tag.

to compile the body of a routine (prolog):
  if the routine is nil, exit.
  if the compiler's abort flag is set, exit.
  add a fragment given the prolog tag.
  add another fragment given the loop tag.

to compile the body of the routine called a string:
  if the compiler's abort flag is set, exit.
  find a routine given the string and the routine index.
  if the routine is nil, abort with "I need a routine to '" then the string then "'."; exit.
  compile the body of the routine.

to compile the body of a routine given a rider (employ):
  move the rider (compiler rules).
  compile a routine reference given the rider.
  convert the routine reference to the routine's employs moniker.
  destroy the routine reference.
  if the rider's token is not ".", abort with "Employ statments should end with a period not '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  if the rider's token is not blank, abort with "Once an employ, only an employ" and the rider; exit.
  find another routine given the routine's employs moniker and the routine index.
  if the other routine is nil, abort with "I can't find the '" then the routine's employs moniker then "' routine you're trying to employ." and the routine's locus; exit.
  compile the body of the other routine.

to compile the call'd part given a rider and a variable:
  if the compiler's abort flag is set, exit.
  if the variable is nil, exit.
  put the variable's name into the variable's type name.
  move the rider (compiler rules).
  scan the variable's name given the rider.

to compile a directory:
  compile the directory (start).
  compile the directory (read the source files).
  compile the directory (scan the source files).
  compile the directory (resolve the types).
  compile the directory (resolve the globals).
  compile the directory (compile the headers of the routines).
  compile the directory (calculate lengths and offsets of types).
  compile the directory (add the built-in memory routines).
  compile the directory (index the routines for utility use).
  compile the directory (compile the bodies of the routines).
  compile the directory (add and compile the built-in startup routine).
  compile the directory (offset parameters and variables).
  compile the directory (address).
  compile the directory (transmogrify).
  compile the directory (link).
  compile the directory (write the exe).
  compile the directory (stop).

to compile a directory (add and compile the built-in startup routine):
  if the compiler's abort flag is set, exit.
  show status "Adding...".
  start the adding built-in startup routine timer.
  add and compile the initialize before run and run and finalize after run routine.
  stop the adding built-in startup routine timer.

to compile a directory (add the built-in memory routines):
  if the compiler's abort flag is set, exit.
  show status "Adding...".
  start the adding built-in memory routines timer.
  add the allocate and deallocate and finalize and destroy routines.
  stop the adding built-in memory routines timer.

to compile a directory (address):
  if the compiler's abort flag is set, exit.
  show status "Addressing...".
  start the addressing timer.
  put 4096 into an address.
  put the address into the import borough's base.
  address the imports given the address.
  put the address minus the import borough's base into the import borough's length.
  round the address up to the nearest multiple of 4096.
  put the address into the data borough's base.
  address the globals given the address.
  address the literals given the address.
  put the address minus the data borough's base into the data borough's length.
  round the address up to the nearest multiple of 4096.
  put the address into the code borough's base.
  address the routines given the address.
  put the address minus the code borough's base into the code borough's length.
  stop the addressing timer.

to compile a directory (calculate lengths and offsets of types):
  if the compiler's abort flag is set, exit.
  show status "Calculating...".
  start the calculating timer.
  calculate the lengths of the types.
  calculate the offsets in the types.
  calculate the redefinition offsets in the types.
  stop the calculating timer.

to compile a directory (compile the bodies of the routines):
  if the compiler's abort flag is set, exit.
  show status "Compiling...".
  start the compiling routine bodies timer.
  compile the bodies of the routines.
  stop the compiling routine bodies timer.

to compile a directory (compile the headers of the routines):
  if the compiler's abort flag is set, exit.
  show status "Compiling...".
  start the compiling routine headers timer.
  compile the headers of the routines.
  stop the compiling routine headers  timer.

to compile a directory (index the routines for utility use):
  if the compiler's abort flag is set, exit.
  show status "Utilitizing...".
  start the indexing utilities timer.
  index the routines for utility use.
  scrub the utility index.
  reindex the utility index.
  stop the indexing utilities timer.

to compile a directory (link):
  if the compiler's abort flag is set, exit.
  show status "Linking...".
  start the linking timer.
  link.
  stop the linking timer.

to compile a directory (offset parameters and variables):
  if the compiler's abort flag is set, exit.
  show status "Offsetting...".
  start the offsetting timer.
  offset the parameters in the routines.
  offset the locals in the routines.
  stop the offsetting timer.

to compile a directory (read the source files):
  if the compiler's abort flag is set, exit.
  show status "Reading...".
  start the reading timer.
  read the source files.
  stop the reading timer.

to compile a directory (resolve the globals):
  if the compiler's abort flag is set, exit.
  show status "Resolving...".
  start the resolving globals timer.
  resolve the globals.
  stop the resolving globals timer.

to compile a directory (resolve the types):
  if the compiler's abort flag is set, exit.
  show status "Resolving...".
  start the resolving types timer.
  resolve the types (expand things).
  resolve the types (index plurals).
  resolve the types (base types).
  resolve the types (optional info).
  stop the resolving types timer.

to compile a directory (scan the source files):
  if the compiler's abort flag is set, exit.
  show status "Scanning...".
  start the scanning timer.
  scan the source files.
  stop the scanning timer.

to compile a directory (start):
  show status "Starting...".
  finalize the compiler.
  start the compiler's timer.
  initialize the compiler given the directory.
  add the built-in types.

to compile a directory (stop):
  stop the compiler's timer.
  show status "".

to compile a directory (transmogrify):
  if the compiler's abort flag is set, exit.
  show status "Mogrifying...".
  start the transmogrifying timer.
  transmogrify the routines.
  stop the transmogrifying timer.

to compile a directory (write the exe):
  if the compiler's abort flag is set, exit.
  show status "Writing...".
  start the writing timer.
  write the compiler's exe to the compiler's exe path.
  if the i/o error is not blank, abort with the i/o error.
  stop the writing timer.

to compile an expression given a rider:
  if the compiler's abort flag is set, exit.
  compile a term given the rider.
  put the term into the expression.
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is not any operator, exit.
  if the rider's token is "divided", compile the expression given the rider (divided); repeat.
  if the rider's token is "minus", compile the expression given the rider (minus); repeat.
  if the rider's token is "plus", compile the expression given the rider (plus); repeat.
  if the rider's token is "then", compile the expression given the rider (then); repeat.
  if the rider's token is "times", compile the expression given the rider (times); repeat.

to compile an expression given a rider (divided):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the rider's token is not "by", abort with "I really prefer the phrase 'divided BY'." and the rider; exit.
  if the expression's variable is nil, abort with "Invalid 'divided by', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'divided by', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given the expression's type name and the rider's token's first.
  add several fragments given "put" and the expression's variable and "into" and the intermediate and the rider's token's first.
  add several fragments given "divide" and the intermediate and "by" and the term's variable and the rider's token's first.
  put the intermediate into the expression's variable.
  clear the expression's phrase.

to compile an expression given a rider (minus):
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'minus', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'minus', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given the expression's type name and the rider's token's first.
  add several fragments given "put" and the expression's variable and "into" and the intermediate and the rider's token's first.
  add several fragments given "subtract" and the term's variable and "from" and the intermediate and the rider's token's first.
  put the intermediate into the expression's variable.
  clear the expression's phrase.

to compile an expression given a rider (plus):
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'plus', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'plus', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given the expression's type name and the rider's token's first.
  add several fragments given "put" and the expression's variable and "into" and the intermediate and the rider's token's first.
  add several fragments given "add" and the term's variable and "to" and the intermediate and the rider's token's first.
  put the intermediate into the expression's variable.
  clear the expression's phrase.

to compile an expression given a rider (then):
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'then', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'then', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given "string" and the rider's token's first.
  add the put or convert fragments given the expression's variable and the intermediate and the rider's token's first.
  convert the term for concatenation given the rider.
  add several fragments given "append" and the term's variable and "to" and the intermediate and the rider's token's first.
  put the intermediate into the expression's variable.
  clear the expression's phrase.

to compile an expression given a rider (times):
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'times', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'times', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given the expression's type name and the rider's token's first.
  add several fragments given "put" and the expression's variable and "into" and the intermediate and the rider's token's first.
  add several fragments given "multiply" and the intermediate and "by" and the term's variable and the rider's token's first.
  put the intermediate into the expression's variable.
  clear the expression's phrase.

to compile the header of a routine:
  if the routine is nil, exit.
  if the compiler's abort flag is set, exit.
  slap a rider on the routine's routine header.
  move the rider (compiler rules).
  if the rider's token is "decide", compile the header of the routine given the rider (decider); exit.
  if the rider is the start of any function, compile the header of the routine given the rider (function); exit.
  if the rider's token is "compatibly", compile the header of the routine given the rider (callback); exit.
  compile the header of the routine given the rider (procedure).

to compile the header of a routine given a rider (callback):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  set the routine's callback flag.
  compile the routine's monikettes and the routine's parameters given the rider.
  convert the routine's monikettes to the routine's moniker.
  if the routine's moniker is in the routine index, abort with "I already know how to '" then the routine's moniker then "'." and the routine's locus; exit.
  index the routine given the routine's monikettes and the routine index.

to compile the header of a routine given a rider (decider):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the rider's token is not "if", abort with "It's 'Decide IF.' We always say, 'Decide IF'. Got it?" and the rider; exit.
  move the rider (compiler rules).
  set the routine's decider flag.
  compile the routine's monikettes and the routine's parameters given the rider.
  if any of the routine's monikettes are negative words, abort with "It's a bad idea to use negatives in decider names." and the rider; exit.
  convert the routine's monikettes to the routine's moniker.
  if the routine's moniker is in the routine index, abort with "I already know how to '" then the routine's moniker then "'." and the routine's locus; exit.
  index the routine given the routine's monikettes and the routine index.

to compile the header of a routine given a rider (function):
  if the compiler's abort flag is set, exit.
  set the routine's function flag.
  add a monikette to the routine's monikettes given "put".
  move the rider (compiler rules).
  if the rider's token is any indefinite article, set a flag.
  if the flag is set, compile the routine's monikettes and the routine's parameters given the rider (indefinite article).
  if the flag is not set, compile the routine's monikettes and the routine's parameters given the rider (definite article).
  if the rider's token is not any possessive, abort with "An 's is missing or misplaced here." and the rider; exit.
  move the rider (compiler rules).
  scan a name given the rider.
  add another monikette to the routine's monikettes given "'s " then the name.
  if the rider's token is not "into", abort with "I was expecting the word 'into', but found '" then the rider's token then "'." and the rider; exit.
  add a third monikette to the routine's monikettes given "into".
  convert the routine's monikettes to a moniker.
  if the moniker is in the routine index, abort with "I already know how to '" then the moniker then "'." and the routine's locus; exit.
  index the routine given the routine's monikettes and the routine index.
  move the rider (compiler rules).
  if the rider's token is not any indefinite article, abort with "I was expecting an indefinite article, but found '" then the rider's token then "'." and the rider; exit.
  compile the routine's monikettes and the routine's parameters given the rider (indefinite article).
  if the rider's token is not blank, abort with "There's extra stuff on the end of this function." and the rider; exit.
  convert the routine's monikettes to the routine's moniker.
  index the routine given the routine's monikettes and the routine index. \ for employs

to compile the header of a routine given a rider (procedure):
  if the compiler's abort flag is set, exit.
  compile the routine's monikettes and the routine's parameters given the rider.
  convert the routine's monikettes to the routine's moniker.
  if the routine's moniker is in the routine index, abort with "I already know how to '" then the routine's moniker then "'." and the routine's locus; exit.
  index the routine given the routine's monikettes and the routine index.

to compile the headers of some routines:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, exit.
  compile the header of the routine.
  repeat.

to compile a literal given a rider:
  if the compiler's abort flag is set, exit.
  add the literal to the literals given the rider's token's first.
  if the rider's token is any flag literal, compile the literal given the rider (flag); exit.
  if the rider's token is any hex literal, compile the literal given the rider (hex); exit.
  if the rider's token is any numeric literal, compile the literal given the rider (numeric); exit.
  if the rider's token is any pointer literal, compile the literal given the rider (pointer); exit.
  if the rider's token is any string literal, compile the literal given the rider (string); exit.
  abort with "Internal error - compile a term given a rider (literal)" and the rider.

to compile a literal given a rider (flag):
  if the compiler's abort flag is set, exit.
  convert the rider's token to a flag.
  convert the flag to the literal's data.
  move the rider (compiler rules).
  put "flag" into the literal's type name.
  resolve the literal.

to compile a literal given a rider (hex):
  if the compiler's abort flag is set, exit.
  put the rider's token into a nibble substring.
  add 1 to the nibble substring's first.
  convert the nibble substring to the literal's data.
  move the rider (compiler rules).
  put "hex string" into the literal's type name.
  resolve the literal.

to compile a literal given a rider (numeric - integer):
  if the compiler's abort flag is set, exit.
  convert the rider's token to a number.
  convert the number to the literal's data.
  move the rider (compiler rules).
  put "number" into the literal's type name.
  resolve the literal.

to compile a literal given a rider (numeric - ratio):
  if the compiler's abort flag is set, exit.
  convert the rider's token to a ratio.
  convert the ratio to the literal's data.
  move the rider (compiler rules).
  put "ratio" into the literal's type name.
  resolve the literal.

to compile a literal given a rider (numeric - with unit of measure):
  if the compiler's abort flag is set, exit.
  convert the rider's token to a ratio.
  move the rider (compiler rules).
  scan a name given the rider.
  find a type given the name and the type index.
  if the type is nil, abort with "'" then the name then "' is an invalid unit of measure." and the literal's locus; exit.
  if the type cannot be reduced to "number", abort with "'" then the name then "' is an invalid unit of measure." and the literal's locus; exit.
  put the type's scale into a final ratio.
  if the type's scale is 0, put 1/1 into the final ratio.
  multiply the final ratio by the ratio.
  reduce the final ratio.
  if the final ratio's denominator is 0, abort with "We seem to have an invalid unit of measure here." and the literal's locus.
  put the final ratio's numerator divided by the final ratio's denominator into a number.
  put the type's name into the literal's type name.
  convert the number to the literal's data.
  resolve the literal.

to compile a literal given a rider (numeric):
  if the compiler's abort flag is set, exit.
  if the rider is followed by any unit of measure, compile the literal given the rider (numeric - with unit of measure); exit.
  if the rider's token is any integer literal, compile the literal given the rider (numeric - integer); exit.
  if the rider's token is any ratio literal, compile the literal given the rider (numeric - ratio); exit.
  if the rider's token is any mixed literal, compile the literal given the rider (numeric - ratio); exit.

to compile a literal given a rider (pointer):
  if the compiler's abort flag is set, exit.
  convert nil to the literal's data.
  move the rider (compiler rules).
  put "pointer" into the literal's type name.
  resolve the literal.

to compile a literal given a rider (string):
  if the compiler's abort flag is set, exit.
  put the rider's token into the literal's data.
  unquote the literal's data.
  move the rider (compiler rules).
  put "string" into the literal's type name.
  resolve the literal.

to compile some monikettes and some parameters given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is "the", compile the monikettes and the parameters given the rider (definite article); repeat.
  if the rider's token is any indefinite article, compile the monikettes and the parameters given the rider (indefinite article); repeat.
  if the rider's token is any monikette string, compile the monikettes and the parameters given the rider (monikette string); repeat.
  abort with "'" then the rider's token then "' is not valid in a routine header." and the rider.

to compile some monikettes and some parameters given a rider (definite article):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  scan a name given the rider.
  if the compiler's abort flag is set, exit.
  prepend "the " to the name.
  add a monikette to the monikettes given the name.

to compile some monikettes and some parameters given a rider (indefinite article):
  if the compiler's abort flag is set, exit.
  add a parameter to the parameters given "parameter" and the rider's token's first.
  if the rider's token is "another", put "other" into the parameter's name.
  move the rider (compiler rules).
  scan a name given the rider.
  extend the parameter's name with the name.
  if the rider's token is "called", compile the call'd part given the rider and the parameter.
  resolve the parameter.
  if the parameter is duplicated in the parameters, abort with "Dude, you already have a parameter called '" then the parameter's name then "'." and the parameter's locus; exit.
  add a monikette to the monikettes given the parameter's type.

to compile some monikettes and some parameters given a rider (monikette string):
  if the compiler's abort flag is set, exit.
  add a monikette to the monikettes given the rider's token.
  move the rider (compiler rules).

to compile some monikettes given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is any monikette string, add a monikette to the monikettes given the rider's token; move the rider (compiler rules); repeat.
  if the rider's token is not the start of any expression, exit.
  compile an expression given the rider.
  if the compiler's abort flag is set, exit.
  add another monikette to the monikettes given the expression.
  repeat.

to compile the next statement given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is "if", compile the next statement given the rider (if); exit.
  if the rider's token is "loop", compile the next statement given the rider (loop); exit.
  if the rider's token is "privatize", compile the next statement given the rider (privatize); exit.
  if the rider's token is not the start of any statement, abort with "I was expecting a statement here, but I found '" then the rider's token then "'." and the rider; exit.
  compile the next statement given the rider (other).
  if the rider's token is not the period byte, abort with "You seem to have forgotten a period around here." and the rider; exit.
  move the rider (compiler rules).

to compile the next statement given a rider (break):
  add a fragment given the break tag.
  move the rider (compiler rules).

to compile the next statement given a rider (call - external):
  put the rider's token into a string.
  unquote the string.
  move the rider (compiler rules).
  if the rider's token is not any string literal, abort with "Gee, I was expecting a quoted entry name, but I found '" then the rider's token then "'." and the rider; exit.
  put the rider's token into another string.
  unquote the other string.
  move the rider (compiler rules).
  add an entry to the imports given the string and the other string.
  if the rider's token is "with", compile the next statement given the rider (call - with clause).
  if the rider's token is "returning", compile the next statement given the rider returning a term (call - returning part).
  add a fragment given the call external tag and the entry.
  if the term is empty, exit.
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add another fragment given the save eax tag and the term's variable.

to compile the next statement given a rider (call - indirect):
  compile an expression given the rider.
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  if the expression's type cannot be reduced to "pointer", abort with "I really need a pointer type in this CALL statement." and the rider; exit.
  if the rider's token is "with", compile the next statement given the rider (call - with clause).
  if the rider's token is "returning", compile the next statement given the rider returning a term (call - returning part).
  add a fragment given the call indirect tag and the expression's variable.
  if the term is empty, exit.
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add another fragment given the save eax tag and the term's variable.

to compile the next statement given a rider (call - internal):
  compile some monikettes given the rider.
  find a routine given the monikettes.
  if the routine is not nil, add push fragments given the monikettes.
  if the routine is not nil, destroy the monikettes; add a fragment given the call internal tag and the routine; exit.
  convert the monikettes to a moniker.
  destroy the monikettes.
  abort with "I don't know how to '" then the moniker then "'." and the rider.

to compile the next statement given a rider (call - with clause): \ this guy is recursise so parameters get passed right to left
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile an expression given the rider.
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  if the expression's type is not value pushable, abort with "'" then the expression's type's name then "' can't be passed properly." and the rider; exit.
  if the rider's token is "and", compile the next statement given the rider (call - with clause).
  add a fragment given the push value tag and the expression's variable.

to compile the next statement given a rider (call):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the rider's token is any string literal, compile the next statement given the rider (call - external); exit.
  compile the next statement given the rider (call - indirect).  

to compile the next statement given a rider (exit):
  if the current routine's decider flag is set, abort with "What does 'exit' mean here? Yes? No? Maybe?" and the rider; exit.
  add a fragment given the exit tag.
  move the rider (compiler rules).

to compile the next statement given a rider (if):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile some monikettes given the rider.
  remove any negatives from the monikettes returning a flag.
  find a routine given the monikettes.
  if the routine is not nil, add push fragments given the monikettes.
  if the routine is nil, convert the monikettes to a moniker.
  destroy the monikettes.
  if the routine is nil, abort with "I need a decider with the words '" then the moniker then "'." and the rider; exit.
  if the routine's decider flag is not set, abort with "Yeah, I'm going to need a decider here, ok?" and the rider; exit.
  if the rider's token is not the comma byte, abort with "I expected a comma around here, but I found '" then the rider's token then "'." and the rider; exit.
  add a fragment given the call internal tag and the routine.
  if the flag is set, add another fragment given the not tag.
  add a third fragment given the jump false tag.
  move the rider (compiler rules).
  loop.
  compile the next statement given the rider (other).
  if the compiler's abort flag is set, exit.
  if the rider's token is the semi-colon byte, move the rider (compiler rules); repeat.
  if the rider's token is not the period byte, abort with "I'm thinking period, but you've got '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  add a fourth fragment given the end if tag.

to compile the next statement given a rider (intel):
  move the rider (compiler rules).
  if the rider's token is not any hex literal, abort with "I need some machine code here, I found '" then the rider's token then "'." and the rider; exit.
  add a fragment given the intel tag.
  put the rider's token into a nibble substring.
  add 1 to the nibble substring's first.
  convert the nibble substring to the fragment's code.
  move the rider (compiler rules).

to compile the next statement given a rider (loop):
  if the compiler's abort flag is set, exit.
  add a fragment given the loop tag.
  move the rider (compiler rules).
  if the rider's token is not the period byte, abort with "You seem to have forgotten a period around here." and the rider; exit.
  move the rider (compiler rules).

to compile the next statement given a rider (other):
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is "exit", compile the next statement given the rider (exit); exit.
  if the rider's token is "repeat", compile the next statement given the rider (repeat); exit.
  if the rider's token is "break", compile the next statement given the rider (break); exit.
  if the rider's token is "say", compile the next statement given the rider (say); exit.
  if the rider's token is "intel", compile the next statement given the rider (intel); exit.
  if the rider's token is "push", compile the next statement given the rider (push); exit.
  if the rider's token is "call", compile the next statement given the rider (call); exit.
  if the rider's token is "point", compile the next statement given the rider (point); exit.
  if the rider's token is "if", abort with "Nested 'if' statements are a sure sign of unclear thinking. Think again." and the rider; exit.
  if the rider's token is "privatize", abort with "The 'privatize' statement cannot be used here." and the rider; exit.
  if the rider's token is "loop", abort with "Looping inside an 'if' statement is a good way to lose your lunch." and the rider; exit.
  if the rider's token is "employ", abort with "'Employ' must be the first and only imperative in a routine." and the rider; exit.
  compile the next statement given the rider (call - internal).

to compile the next statement given a rider (point):
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's kind is "literal", abort with "You've got the wrong kind of variable here." and the rider.
  if the term's type's length is not 4, abort with "You've got the wrong kind of variable here." and the rider.
  if the rider's token is not "to", abort with "I was expecting the word 'to', but found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  if the rider's token is not "routine", abort with "I was expecting the word 'routine' but found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  compile a routine reference given the rider.
  convert the routine reference to a moniker.
  destroy the routine reference.
  find a routine given the moniker and the routine index.
  if the routine is nil, abort with "I can't find the '" then the moniker then "' routine to which you are trying to point." and the rider; exit.
  add a fragment given the routine address tag and the routine.
  put the term's variable into the fragment's variable.

to compile the next statement given a rider (privatize):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile a term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'privatize', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's kind is not "parameter", abort with "You can only privatize parameters." and the rider; exit.
  add a local to the current routine's locals given "local" and the rider's token's first.
  put the term's name into the local's name.
  put the term's nickname into the local's nickname.
  put the term's type name into the local's type name.
  resolve the local.
  prepend "original " to the term's name.
  if the term's nickname is not blank, prepend "original " to the term's nickname.
  add several fragments given "put" and the term's variable and "into" and the local and the rider's token's first.
  if the rider's token is not the period byte, abort with "You seem to have forgotten a period around here." and the rider; exit.
  move the rider (compiler rules).

to compile the next statement given a rider (push):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile an expression given the rider.
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'push', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  if the expression's type is not value pushable, abort with "Values of type '" then the expression's type's name then "' can't be pushed." and the rider; exit.
  add a fragment given the push value tag and the expression's variable.

to compile the next statement given a rider (repeat):
  add a fragment given the repeat tag.
  move the rider (compiler rules).

to compile the next statement given a rider (say):
  if the current routine's decider flag is not set, compile the next statement given the rider (call - internal); exit.
  move the rider (compiler rules).
  compile an expression given the rider.
  if the compiler's abort flag is set, exit.
  if the expression's variable is nil, abort with "Invalid 'say', I don't understand the variable '" then the expression's phrase then "'." and the rider; exit.
  if the expression's type cannot be reduced to "flag", abort with "I need a definite 'yes' or 'no' here." and the rider; exit.
  add a fragment given the load eax tag and the expression's variable.
  add another fragment given the exit tag.

to compile the next statement given a rider returning a term (call - returning part):
  move the rider (compiler rules).
  compile the term given the rider.
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's type is not value pushable, abort with "A simple 1, 2, or 4-byte variable is required in the 'returning' clause." and the rider.

to compile a routine reference given a rider:
  if the rider's token is "to", move the rider (compiler rules).
  if the rider is the start of any function, compile the routine reference given the rider (function); exit.
  if the rider's token is "decide", compile the routine reference given the rider (decide).
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is ".", exit.
  if the rider's token is "the", compile the routine reference given the rider (definite article); repeat.
  if the rider's token is any indefinite article, compile the routine reference given the rider (indefinite article); repeat.
  if the rider's token is any monikette string, compile the routine reference given the rider (monikette string); repeat.
  abort with "'" then the rider's token then "' is not valid in an employ statement." and the rider.

to compile a routine reference given a rider (decide):
  move the rider (compiler rules).
  if the rider's token is not "if", abort with "We always say DECIDE IF, not DECIDE and then '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).

to compile a routine reference given a rider (definite article):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  scan a name given the rider.
  prepend "the " to the name.
  add a monikette to the routine reference given the name.

to compile a routine reference given a rider (function):
  if the compiler's abort flag is set, exit.
  add a monikette to the routine reference given "put".
  move the rider (compiler rules).
  if the rider's token is any indefinite article, set a flag.
  if the flag is set, compile the routine reference given the rider (indefinite article).
  if the flag is not set, compile the routine reference given the rider (definite article).
  if the rider's token is not any possessive, abort with "I was expecting an 's, but found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  scan a name given the rider.
  add another monikette to the routine reference given "'s " then the name.
  if the rider's token is not "into", abort with "I was expecting the word 'into', but found '" then the rider's token then "'." and the rider; exit.
  add a third monikette to the routine reference given "into".
  move the rider (compiler rules).
  if the rider's token is not any indefinite article, abort with "I was expecting an indefinite article, but found '" then the rider's token then "'." and the rider; exit.
  compile the routine reference given the rider (indefinite article).

to compile a routine reference given a rider (indefinite article):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  scan a name given the rider.
  find a type and a nickname given the name.
  if the type is nil, abort with "Invalid employ statement, I don't understand '" then the name then "'." and the rider; exit.
  add a monikette to the routine reference given the type.

to compile a routine reference given a rider (monikette string):
  if the compiler's abort flag is set, exit.
  add a monikette to the routine reference given the rider's token.
  move the rider (compiler rules).

to compile a term given a rider:
  clear the term.
  if the compiler's abort flag is set, exit.
  compile the term given the rider (common part).
  if the rider's token is "AS", compile the term given the rider (as part).
  if the rider's token is "/", compile the term given the rider (runtime ratio).

to compile a term given a rider (as part):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid 'as', I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  if the rider's token is not any indefinite article, abort with "I was hoping for an indefinite article after AS, but I found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  scan a type name given the rider.
  find a type given the type name and the type index.
  if the type is nil, abort with "I can't find the '" then the type name then "' type." and the rider; exit.
  add a scratch given the type's name and the rider's token's first.
  add a fragment given the load address tag and the term's variable and the scratch.
  put the scratch into the term's variable.
  clear the term's phrase.

to compile a term given a rider (common part):
  if the compiler's abort flag is set, exit.
  if the rider's token is the dash byte, compile the term given the rider (negated term); exit.
  if the rider's token is the cross byte, compile the term given the rider (posigated term); exit.
  if the rider's token is the start of any variable, compile the term given the rider (variable); exit.
  if the rider's token is the start of any new local, compile the term given the rider (new local); exit.
  if the rider's token is any literal, compile the term given the rider (literal); exit.
  abort with "I expected a term hereabouts but all I found was '" then the rider's token then "'." and the rider.

to compile a term given a rider (dereference - in place):
  if the term's variable is nil, abort with "Internal error - compile a term given a rider (dereference - in place)" and the rider; exit.
  put the term's type's target type's name into the term's type name.
  put the term's type's target type into the term's type.
  add a fragment given the dereference tag and the term's variable.
  clear the term's phrase.

to compile a term given a rider (dereference):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid dereference, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's type's target type is nil, abort with "I'm unable to determine the type of this target." and the rider; exit.
  if the term's kind is "scratch", compile the term given the rider (dereference - in place); exit.
  add a scratch given the term's type's target type's name and the rider's token's first.
  add a fragment given the load address tag and the term's variable and the scratch.
  add another fragment given the dereference tag and the scratch.
  put the scratch into the term's variable.
  clear the term's phrase.

to compile a term given a rider (literal):
  if the compiler's abort flag is set, exit.
  compile a literal given the rider.
  put the literal into the term's variable.
  clear the term's phrase.
  compile the term given the rider (possessives).

to compile a term given a rider (negated term):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile another term given the rider.
  if the compiler's abort flag is set, exit.
  if the other term's variable is nil, abort with "Invalid negate, I don't understand the variable '" then the other term's phrase then "'." and the rider; exit.
  add an intermediate given the other term's type name and the rider's token's first.
  add several fragments given "put" and the other term's variable and "into" and the intermediate and the other term's locus.
  add two fragments given "negate" and the intermediate and the rider's token's first.
  put the intermediate into the term's variable.
  clear the term's phrase.

to compile a term given a rider (new local):
  if the compiler's abort flag is set, exit.
  if the current routine is nil, abort with "I don't know what you're trying to pull here." and the rider; exit.
  add a local to the current routine's locals given "local" and the rider's token's first.
  if the rider's token is "another", put "other" into the local's name.
  move the rider (compiler rules).
  scan a name given the rider.
  extend the local's name with the name.
  if the rider's token is "called", compile the call'd part given the rider and the local.
  resolve the local.
  if the local is duplicated in the current routine's parameters, abort with "'" then the local's name then "' is already in use as a parameter." and the local's locus; exit.
  if the local is duplicated in the current routine's locals,abort with "'" then the local's name then "' is already in use as a local variable." and the local's locus; exit.
  eliminate duplicate nicknames given the local and the current routine's nickname index.
  put the local into the term's variable.
  clear the term's phrase.
  compile the term given the rider (possessives).

to compile a term given a rider (posigated term):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  compile the term given the rider.
  if the term's variable is nil, abort with "Invalid posigate, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  clear the term's phrase.

to compile a term given a rider (possessive - magnitude):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid use of magnitude, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add a literal to the literals given the rider's token's first.
  convert the term's type's length to the literal's data.
  put "number" into the literal's type name.
  resolve the literal.
  put the literal into the term's variable.
  clear the term's phrase.

to compile a term given a rider (possessive - target):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid use of target, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's type cannot be reduced to "pointer", abort with "You can only get the target of pointer types." and the rider; exit.
  compile the term given the rider (dereference).

to compile a term given a rider (possessive - whereabouts):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid use of whereabouts, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  add an intermediate given "pointer" and the rider's token's first. 
  add a fragment given the load address tag and the term's variable and the intermediate.
  put the intermediate into the term's variable.
  clear the term's phrase.

to compile a term given a rider (possessive):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  scan a name given the rider.
  if the compiler's abort flag is set, exit.
  if the name is "magnitude", compile the term given the rider (possessive - magnitude); exit.
  if the name is "target", compile the term given the rider (possessive - target); exit.
  if the name is "whereabouts", compile the term given the rider (possessive - whereabouts); exit.
  compile the term given the rider and the name (possessive - field).

to compile a term given a rider (possessives):
  if the compiler's abort flag is set, exit.
  if the rider's token is not any possessive, exit.
  compile the term given the rider (possessive).
  repeat.  

to compile a term given a rider (runtime ratio):
  if the compiler's abort flag is set, exit.
  if the term's variable is nil, abort with "Invalid use of /, I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  move the rider (compiler rules).
  compile another term given the rider.
  if the compiler's abort flag is set, exit.
  if the other term's variable is nil, abort with "Invalid use of /, I don't understand the variable '" then the other term's phrase then "'." and the rider; exit.
  add an intermediate given "ratio" and the rider's token's first.
  add several fragments given "put" and the term's variable and "and" and the other term's variable and "into" and the intermediate and the rider's token's first.
  put the intermediate into the term's variable.
  clear the term's phrase.

to compile a term given a rider (variable):
  if the compiler's abort flag is set, exit.
  if the current routine is nil, abort with "I don't know what you're trying to pull here." and the rider; exit.
  move the rider (compiler rules).
  scan a name given the rider.
  find a variable given the name.
  put the variable into the term's variable.
  put "the " into the term's phrase.
  append the name to the term's phrase.
  compile the term given the rider (possessives).

to compile a term given a rider and a field term:
  if the compiler's abort flag is set, exit.
  if the field term's dereference flag is set, compile the term given the rider (dereference).  
  if the field term's function is not nil, compile the term given the rider and the field term (function); exit.
  if the term's kind is "scratch", compile the term given the rider and the field term (in place); exit.
  put the field term's field into a field.
  add a scratch given the field's type's name and the rider's token's first.
  add a fragment given the load address tag and the term's variable and the scratch.
  if the field's offset is not 0, add a third fragment given the increment tag and the scratch and the field's offset.
  put the scratch into the term's variable.
  clear the term's phrase.

to compile a term given a rider and a field term (function):
  if the compiler's abort flag is set, exit.
  put the field term's function into a routine.
  put the routine's parameters' last into a parameter.
  if the parameter is nil, abort with "Internal error - compile a term given a rider and an field term (function)." and the rider; exit.
  if the parameter's type is nil, abort with "Internal error 2 - compile a term given a rider and an field term (function)." and the rider; exit.
  add an intermediate given the parameter's type's name and the rider's token's first.
  add a fragment given the push address tag and the intermediate.
  if the field term's push flag is set, add another fragment given the push address tag and the term's variable.
  add a third fragment given the call internal tag and the routine.
  put the intermediate into the term's variable.
  clear the term's phrase.

to compile a term given a rider and a field term (in place):
  if the compiler's abort flag is set, exit.
  put the field term's field into a field.
  put the field's type's name into the term's type name.
  put the field's type into the term's type.
  if the field's offset is not 0, add a third fragment given the increment tag and the term's variable and the field's offset.
  clear the term's phrase.

to compile a term given a rider and a name (possessive - field):
  if the compiler's abort flag is set, exit.
  if the term's variable is not nil, put the term's type into a type.
  find a field term given the term's phrase and the type and the name.
  if the field term is not empty, compile the term given the rider and the field term; exit.
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the type can be reduced to "pointer", put the type's target type into the type.
  if the type is nil, abort with "There's no '" then the name then "' field in a '" then the term's type's name then "'." and the rider; exit.
  loop.
  if the compiler's abort flag is set, exit.
  get a field from the type's fields.
  if the field is nil, abort with "There's no '" then the name then "' field in a '" then the term's type's name then "'." and the rider; exit.
  find a deep field term given "" and the field's type and the name.
  if the deep field term is empty, repeat.
  put the field into a first field term's field.
  if the term's type can be reduced to "pointer", set the first field term's dereference flag.
  compile the term given the rider and the first field term.
  compile the term given the rider and the deep field term.

the compiler has
  a directory,
  a timer,
  an abort flag,
  an abort message,
  an abort path,
  an abort row#,
  a name count,
  a exe buffer,
  a listing buffer.

the compiling routine bodies timer is a timer.

the compiling routine headers timer is a timer.

to convert some monikettes to a moniker:
  convert the monikettes to the moniker given the monikettes' last.

to convert some monikettes to a moniker given a monikette:
  clear the moniker.
  loop.
  get a current monikette from the monikettes.
  if the current monikette is nil, exit.
  append the current monikette to the moniker.
  if the current monikette is the monikette, exit.
  repeat.

to convert a nibble substring to a string: employ convert a nibble string to a hex string.

to convert a term for concatenation given a rider: \ used for right-side THEN operand
  if the term's variable is nil, abort with "I don't understand the variable '" then the term's phrase then "'." and the rider; exit.
  if the term's type can be reduced to "string", exit.
  add an intermediate given "string" and the rider's token's first.
  add the put or convert fragments given the term's variable and the intermediate and the rider's token's first.
  put the intermediate into the term's variable.
  clear the term's phrase.

to copy a field into another field:
  if the field is nil, void the other field; exit.
  allocate memory for the other field.
  put the field's locus into the other field's locus.
  put the field's name into the other field's name.
  put the field's nickname into the other field's nickname.
  put the field's type name into the other field's type name.
  put the field's type into the other field's type.
  put the field's count into the other field's count.
  put the field's redefinition target name into the other field's redefinition target name.
  put the field's reference flag into the other field's reference flag.
  put the field's offset into the other field's offset.

to copy some fields into some other fields:
  get a field from the fields.
  if the field is nil, exit.
  copy the field into another field.
  append the other field to the other fields.
  repeat.

to copy some fields into some other fields (data fields only):
  if the fields' first is nil, exit.
  if the fields' first's next is nil, exit.
  put the fields' first's next's next into a field.
  loop.
  if the field is nil, exit.
  copy the field into another field.
  append the other field to the other fields.
  get the field from the fields.
  repeat.

to copy a monikette into another monikette:
  if the monikette is nil, void the other monikette; exit.
  allocate memory for the other monikette.
  put the monikette's string into the other monikette's string.
  put the monikette's type into the other monikette's type.
  put the monikette's variable into the other monikette's variable.
  \ don't copy substring
  put the monikette's current type into the other monikette's current type.

to copy some monikettes into some other monikettes:
  destroy the other monikettes.
  loop.
  get a monikette from the monikettes.
  if the monikette is nil, exit.
  copy the monikette into another monikette.
  append the other monikette to the other monikettes.
  repeat.

to create an entry:
  allocate memory for the entry.

to create a fragment given a tag:
  allocate memory for the fragment.
  put the tag into the fragment's tag.

to create an import:
  allocate memory for the import.

to create a monikette:
  allocate memory for the monikette.

to create a routine:
  allocate memory for the routine.

to create a source file:
  allocate memory for the source file.

to create a type:
  allocate memory for the type.
  put 0/1 into the type's scale.
  put -1 into the type's length.

to create a variable given a kind:
  allocate memory for the variable.
  put the kind into the variable's kind.
  put 1 into the variable's count.

the current header address is an address.

the current name address is an address.

the current routine is a routine.

the current thunk address is an address.

the data borough is a borough.

to decide if any of some monikettes are negative words:
  get a monikette from the monikettes.
  if the monikette is nil, say no.
  if the monikette's string is any negative word, say yes.
  repeat.

to decide if a byte is any glom byte:
  if the byte is any letter, say yes.
  if the byte is any digit, say yes.
  if the byte is the tilde byte, say yes.
  if the byte is the at-sign byte, say yes.
  if the byte is the number-sign byte, say yes.
  if the byte is the percent-sign byte, say yes.
  if the byte is the ampersand byte, say yes.
  if the byte is the underscore byte, say yes.
  if the byte is the single-quote byte, say yes.
  if the byte is the dash byte, say yes.
  if the byte is the cross byte, say yes.
  if the byte is the slash byte, say yes.
  say no.

to decide if a byte is any mark:
  if the byte is the period byte, say yes.
  if the byte is the comma byte, say yes.
  if the byte is the semi-colon byte, say yes.
  if the byte is the colon byte, say yes.
  if the byte is the exclamation  byte, say yes.
  if the byte is the question-mark byte, say yes.
  say no.

to decide if a byte is any symbol:
  if the byte is the caret byte, say yes.
  if the byte is the bar byte, say yes.
  if the byte is the asterisk byte, say yes.
  if the byte is the cross byte, say yes.
  if the byte is the dash byte, say yes.
  if the byte is the slash byte, say yes.
  if the byte is the left-alligator byte, say yes.
  if the byte is the right-alligator byte, say yes.
  if the byte is the left-brace byte, say yes.
  if the byte is the right-brace byte, say yes.
  if the byte is the equal-sign byte, say yes.
  if the byte is 128, say yes.
  if the byte is 130, say yes.
  if the byte is between 132 and 137, say yes.
  if the byte is 139, say yes.
  if the byte is between 145 and 153, say yes.
  if the byte is 155, say yes.
  if the byte is between 161 and 180, say yes.
  if the byte is between 183 and 191, say yes.
  if the byte is 215, say yes.
  if the byte is 247, say yes.
  say no.

to decide if a field term is empty:
  if the field term's field is not nil, say no.
  if the field term's function is not nil, say no.
  say yes.

to decide if some fields should be finalized:
  get a field from the fields.
  if the field is nil, say no.
  if the field's type should be finalized, say yes.
  repeat.

to decide if a moniker is in an index:
  find a refer given the moniker and the index.
  if the refer is nil, say no.
  if the refer's pointer is nil, say no.
  say yes.

to decide if a monikette is bubbled out:
  if the monikette is nil, say yes.
  if the monikette's current type is not nil, say no.
  if the monikette's current substring is not blank, say no.
  say yes.

to decide if a name is any valid field name:
  if the name is "magnitude", say no.
  if the name is "target", say no.
  if the name is "whereabouts", say no.
  say yes.

to decide if a rider is followed by any unit of measure:
  privatize the rider.
  move the rider (compiler rules).
  if the rider's token is not any name starter, say no.
  scan a name given the rider.
  find a type given the name and the type index.
  if the type is nil, say no.
  if the name is not "times", say yes. \ special because times is an infix operator and a unit of measure
  if the rider's token is the start of any expression, say no.
  say yes.

to decide if a rider is on any nested double-quote:
  if the rider's source starts with """""", say yes.
  say no.

to decide if a rider is on any possessive:
  if the rider's source is blank, say no.
  if the rider's source's first's target is not the single-quote byte, say no.
  if the rider is on any possessive (type 1 - single-quote, s, non-glom-byte), say yes.
  if the rider is on any possessive (type 2 - preceding s, single-quote, non-glom-byte), say yes.
  say no.

to decide if a rider is on any possessive (type 1 - single-quote, s, non-glom-byte):
  if the rider's source does not start with "'s", say no.
  privatize the rider.
  add 2 to the rider's source's first.
  if the rider's source is blank, say yes.
  if the rider's source's first's target is not any glom byte, say yes.
  say no.

to decide if a rider is on any possessive (type 2 - preceding s, single-quote, non-glom-byte):
  privatize the rider.
  if the rider's source's first is the rider's original's first, say no.
  subtract 1 from the rider's source's first.
  if the rider's source's first's target is not the little-s byte or the big-s byte, say no.
  add 2 to the rider's source's first.
  if the rider's source is blank, say yes.
  if the rider's source's first's target is not any glom byte, say yes.
  say no.

to decide if a rider is the start of any function:
  if the compiler's abort flag is set, say no.
  if the rider's token is not "put", say no.
  privatize the rider.
  move the rider (compiler rules).
  if the rider's token is not any article, say no.
  move the rider (compiler rules).
  scan a name given the rider.
  if the rider's token is any possessive, say yes.  

to decide if a string ends with any consonant and another string:
  slap a substring on the string.
  subtract the other string's length from the substring's last.
  if the substring is blank, say no.
  if the substring's last's target is not any consonant, say no.
  if the string does not end with the other string, say no.
  say yes.

to decide if a string ends with any vowel and another string:
  slap a substring on the string.
  subtract the other string's length from the substring's last.
  if the substring is blank, say no.
  if the substring's last's target is not any vowel, say no.
  if the string does not end with the other string, say no.
  say yes.

to decide if a string is any article:
  if the string is any indefinite article, say yes.
  if the string is "the", say yes.
  say no.

to decide if a string is any conjunction:
  if the string is "and", say yes.
  if the string is "both", say yes.
  if the string is "but", say yes.
  if the string is "either", say yes.
  if the string is "neither", say yes.
  if the string is "nor", say yes.
  if the string is "or", say yes.
  say no.

to decide if a string is any flag literal:
  if the string is "yes", say yes.
  if the string is "no", say yes.
  say no.

to decide if a string is any hex literal:
  if the string is blank, say no.
  if the string's first's target is the dollar-sign byte, say yes.
  say no.

to decide if a string is any indefinite article:
  if the string is "a", say yes.
  if the string is "an", say yes.
  if the string is "another", say yes.
  if the string is "some", say yes.
  say no.

to decide if a string is any literal:
  if the string is any pointer literal, say yes.
  if the string is any numeric literal, say yes.
  if the string is any string literal, say yes.
  if the string is any flag literal, say yes.
  if the string is any hex literal, say yes.
  say no.

to decide if a string is any mark:
  if the string's length is not 1, say no.
  if the string's first's target is any mark, say yes.
  say no.

to decide if a string is any monikette string:
  if the string is blank, say no.
  if the string is "the", say no.
  if the string is any indefinite article, say no.
  if the string is any possessive, say no.
  if the string is any literal, say no.
  if the string is any mark, say no.
  if the string is any symbol, say no.
  say yes.

to decide if a string is any name ender: \ compare with name starter
  if the string is any mark, say yes.
  if the string is any symbol, say yes.
  if the string is any article, say yes.
  if the string is any conjunction, say yes.
  if the string is any possessive, say yes.
  if the string is any verb, say yes.
  if the string is any operator, say yes.
  if the string is any preposition, say yes.
  if the string is any qualifier, say yes.
  if the string is any literal, say yes.
  if the string is "called", say yes.
  if the string is "equal", say yes.
  if the string is blank, say yes.
  say no.

to decide if a string is any name starter: \ compare with name ender
  if the string is any mark, say no.
  if the string is any symbol, say no.
  if the string is any article, say no.
  if the string is any conjunction, say yes.
  if the string is any possessive, say no.
  if the string is any verb, say yes.
  if the string is any operator, say yes.
  if the string is any preposition, say yes.
  if the string is any qualifier, say no.
  if the string is any literal, say no.
  if the string is "called", say yes.
  if the string is "equal", say yes.
  if the string is blank, say no.
  say yes.

to decide if a string is any negative word:
  if the string is "not", say yes.
  if the string is "cannot", say yes.
  if the string is "nothing", say yes.
  if the string ends with "n't", say yes.
  say no.

to decide if a string is any operator:
  if the string is "plus", say yes.
  if the string is "minus", say yes.
  if the string is "times", say yes.
  if the string is "divided", say yes.
  if the string is "then", say yes.
  say no.

to decide if a string is any pause:
  if the string is ",", say yes.
  if the string is ";", say yes.
  if the string is "and", say yes.
  if the string is "or", say yes.
  say no.

to decide if a string is any pointer literal:
  if the string is "nil", say yes.
  say no.

to decide if a string is any possessive:
  if the string is "'s", say yes.
  if the string is "'", say yes.
  say no.

to decide if a string is any preposition:
  if the string is "about", say yes.
  if the string is "above", say yes.
  if the string is "across", say yes.
  if the string is "after", say yes.
  if the string is "against", say yes.
  if the string is "along", say yes.
  if the string is "among", say yes.
  if the string is "anywhere", say yes.
  if the string is "around", say yes.
  if the string is "as", say yes.
  if the string is "at", say yes.
  if the string is "back", say yes.
  if the string is "backward", say yes.
  if the string is "before", say yes.
  if the string is "beginning", say yes.
  if the string is "behind", say yes.
  if the string is "below", say yes.
  if the string is "beneath", say yes.
  if the string is "beside", say yes.
  if the string is "between", say yes.
  if the string is "beyond", say yes.
  if the string is "by", say yes.
  if the string is "down", say yes.
  if the string is "downward", say yes.
  if the string is "ending", say yes.
  if the string is "except", say yes.
  if the string is "finishing", say yes.
  if the string is "for", say yes.
  if the string is "forward", say yes.
  if the string is "from", say yes.
  if the string is "given", say yes.
  if the string is "giving", say yes.
  if the string is "in", say yes.
  if the string is "inside", say yes.
  if the string is "into", say yes.
  if the string is "left", say yes.
  if the string is "leftward", say yes.
  if the string is "near", say yes.
  if the string is "of", say yes.
  if the string is "off", say yes.
  if the string is "on", say yes.
  if the string is "out", say yes.
  if the string is "outside", say yes.
  if the string is "over", say yes.
  if the string is "past", say yes.
  if the string is "returning", say yes.
  if the string is "right", say yes.
  if the string is "rightward", say yes.
  if the string is "somewhere", say yes.
  if the string is "starting", say yes.
  if the string is "thru", say yes.
  if the string is "through", say yes.
  if the string is "throughout", say yes.
  if the string is "to", say yes.
  if the string is "toward", say yes.
  if the string is "towards", say yes.
  if the string is "under", say yes.
  if the string is "underneath", say yes.
  if the string is "until", say yes.
  if the string is "unto", say yes.
  if the string is "up", say yes.
  if the string is "upward", say yes.
  if the string is "upon", say yes.
  if the string is "using", say yes.
  if the string is "via", say yes.
  if the string is "while", say yes.
  if the string is "with", say yes.
  if the string is "within", say yes.
  if the string is "without", say yes.
  say no.

to decide if a string is any qualifier:
  if the string is blank, say no.
  if the string's first's target is the left-paren byte, say yes.
  say no.

to decide if a string is any string literal:
  if the string is blank, say no.
  if the string's first's target is the double-quote byte, say yes.
  say no.

to decide if a string is any symbol:
  if the string's length is not 1, say no.
  if the string's first's target is any symbol, say yes.
  say no.

to decide if a string is any verb:
  if the string is "are", say yes. \ are not \ aren't
  if the string is "be", say yes. \
  if the string is "can", say yes. \ cannot \ can't
  if the string is "cannot", say yes. 
  if the string is "could", say yes. \ could not \ couldn't
  if the string is "do", say yes. \ do not \ don't
  if the string is "does", say yes. \ does not \ doesn't
  if the string is "is", say yes. \ is not \ isn't
  if the string is "may", say yes. \ may not \ mayn't
  if the string is "should", say yes. \ should not \ shouldn't
  if the string is "was", say yes. \ was not \ wasn't
  if the string is "will", say yes. \ will not \ won't
  if the string is "would", say yes. \ would not \ wouldn't
  if the string is "has", say yes. \ used in type definitions
  if the string is "have", say yes. \ used in type definitions
  if the string ends with "n't", say yes.
  \ trouble makers
  if the string is "begins", say yes. \ does not begin \ doesn't begin
  if the string is "ends", say yes. \ does not end \ doesn't end
  if the string is "looks", say yes. \ does not look \ doesn't look
  if the string is "needs", say yes. \ does not need \ doesn't need
  if the string is "starts", say yes. \ does not start \ doesn't start
  say no.

to decide if a string is the start of any definition:
  if the string is "to", say yes.
  if the string is "a", say yes.
  if the string is "an", say yes.
  if the string is "the", say yes.
  if the string is "some", say yes.
  say no.

to decide if a string is the start of any expression:
  if the string is any sign, say yes.
  if the string is any indefinite article, say yes.
  if the string is "the", say yes.
  if the string is any literal, say yes.
  say no.

to decide if a string is the start of any global:
  if the string is "the", say yes.
  say no.

to decide if a string is the start of any new local:
  if the string is any indefinite article, say yes.
  say no.

to decide if a string is the start of any optional info:
  if the string is "to", say yes.
  if the string is "with", say yes.
  say no.

to decide if a string is the start of any routine:
  if the string is "to", say yes.
  say no.

to decide if a string is the start of any statement:
  if the string is the start of any definition, say no.
  if the string is any literal, say no.
  if the string is any mark, say no.
  if the string is blank, say no.
  say yes.

to decide if a string is the start of any type:
  if the string is "a", say yes.
  if the string is "an", say yes.
  if the string is "some", say yes.
  say no.

to decide if a string is the start of any variable:
  if the string is "the", say yes.
  say no.

to decide if a term is empty:
  if the term's variable is not nil, say no.
  if the term's phrase is not blank, say no.
  say yes.

to decide if a type can be reduced to a string using the base name:
  if the type is nil, say no.
  if the type's name is the string, say yes.
  if the type's cooking flag is set, say no.
  set the type's cooking flag.
  find a base type given the type's base name and the type index.
  if the base type is nil, clear the type's cooking flag; say no.
  if the base type can be reduced to the string using the base name, clear the type's cooking flag; say yes.
  clear the type's cooking flag.
  say no.

to decide if a type can be reduced to a type name:
  if the type is nil, say no.
  privatize the type.
  loop.
  if the type is nil, say no.
  if the type's name is the type name, say yes.
  if the type's base type is the type, say no.
  put the type's base type into the type.
  repeat.

to decide if a type is any built-in type:
  if the type is nil, say no.
  if the type is the type's base type, say yes.
  say no.

to decide if a type is value pushable:
  if the type is nil, say no.
  if the type is nil, say no.
  if the type's length is 4, say yes.
  if the type's length is 2, say yes.
  if the type's length is 1, say yes.
  say no.

to decide if a type should be finalized:
  if the type is nil, say no.
  if the type can be reduced to "substring", say no.
  if the type can be reduced to "string", say yes.
  if the type's fields should be finalized, say yes.
  say no.

to decide if a type should be forgotten:
  if the type is nil, say no.
  if the type's name is "thing", say no.
  if the type's name is "things", say no.
  if the type can be reduced to "things", say yes.
  if the type can not be reduced to "pointer", say no.
  if the type's target type is nil, say no.
  if the type's target type cannot be reduced to "pointer", say yes.
  if the type's target type should not be forgotten, say no.
  say yes.

to decide if a variable is duplicated in some variables:
  get another variable from the variables.
  if the other variable is nil, say no.
  if the other variable's name is blank, repeat.
  if the other variable is the variable, repeat.
  if the other variable's name is the variable's name, say yes.
  repeat.

the dereference tag is a tag equal to 5.

a dos header is a record with
  a wyrd called signature,
  a wyrd called numberofbytesonlastpage,
  a wyrd called numberofpages,
  a wyrd called relocuss,
  a wyrd called sizeofheaderinparagraphs,
  a wyrd called minimumextraparagraphs,
  a wyrd called maximumextraparagraphs,
  a wyrd called initialrelativess,
  a wyrd called initialsp,
  a wyrd called initialchecksum,
  a wyrd called initialip,
  a wyrd called initialirelativecs,
  a wyrd called addressofrelocationtableinfile,
  a wyrd called overlynumber,
  8 bytes called resveredbytes,
  a wyrd called oemidentifier,
  a wyrd called oeminfo,
  20 bytes called reservedwords,  
  a number called addressofpeheaderinfile.

to eliminate duplicate nicknames from some variables:
  create an index given 101.
  eliminate duplicate nicknames from the variables given the index.
  destroy the index.

to eliminate duplicate nicknames from some variables given an index:
  if the index is nil, exit.
  loop.
  get a variable from the variables.
  if the variable is nil, exit.
  eliminate duplicate nicknames given the variable and the index.
  repeat.

to eliminate duplicate nicknames given a variable and an index:
  if the variable is nil, exit.
  if the index is nil, exit.
  find another variable given the variable's nickname and the index.
  if the other variable is nil, find the other variable given the variable's name and the index.
  if the other variable is nil, index the variable given the variable's nickname and the index; exit.
  clear the other variable's nickname.
  clear the variable's nickname.

the end if tag is a tag equal to 6.

an entry is a thing with
  a name address,
  a thunk address,
  a name,
  an address.

the epilog tag is a tag equal to 7.

the exit tag is a tag equal to 8.

an expression is a term.

to extend a string with another string:
  if the other string is blank, exit.
  if the string is not blank, append the space byte to the string.
  append the other string to the string.

a field is a variable.

a field term has
  a dereference flag,
  a field (reference),
  a function routine (reference),
  a push flag.

to finalize the compiler:
  destroy the utility index.
  destroy the routine index.
  destroy the literal index.
  destroy the global index.
  destroy the type index.
  destroy the imports.
  destroy the routines.
  destroy the literals.
  destroy the globals.
  destroy the types.
  destroy the source files.

the finalize tag is a tag equal to 9.

to find an entry given a string and some entries:
  void the entry.
  loop.
  get the entry from the entries.
  if the entry is nil, exit.
  if the entry's name is the string, exit.
  repeat.

to find a field term given a phrase and a type and a name:
  clear the field term.
  find the field term given the type and the name.
  if the field term's field is not nil, exit.
  if the phrase is not blank, find a routine given "put" and the phrase and "'s " then the name and "into".
  if the routine is not nil, put the routine into the field term's function; exit.
  if the type is nil, exit.
  find the routine given "put" and the type and "'s " then the name and "into".
  if the routine is not nil, set the field term's push flag; put the routine into the field term's function; exit.
\  code below for looking deep within pointers - a debatable feature
\  if the type's target type is not nil, find the routine given "put" and the type's target type and "'s " then the name and "into".
\  if the routine is not nil, set the field term's dereference flag; put the routine into the field term's function; exit.

to find a field term given a type and a name:
  if the type is nil, exit.
  find a field given the name and the type's fields.
  if the field is not nil, put the field into the field term's field; exit.
  if the type's target type is not nil, find the field given the name and the type's target type's fields.
  if the field is not nil, set the field term's dereference flag; put the field into the field term's field; exit.

to find a fragment given another fragment and a tag:
  put the other fragment into the fragment.
  loop.
  if the fragment is nil, exit.
  if the fragment's tag is the tag, exit.
  put the fragment's next into the fragment.
  repeat.

to find a fragment given another fragment and a tag (backwards):
  put the other fragment into the fragment.
  loop.
  if the fragment is nil, exit.
  if the fragment's tag is the tag, exit.
  put the fragment's previous into the fragment.
  repeat.

to find an import given a string:
  void the import.
  loop.
  get the import from the imports.
  if the import is nil, exit.
  if the import's name is the string, exit.
  repeat.

to find a path and a row# given a byte pointer:
  clear the path.
  put 0 into the row#.
  find a source file given the byte pointer.
  if the source file is nil, exit.
  put the source file's path into the path.
  find the row# given the source file and the byte pointer.

to find a routine given a moniker and a monikette and an index:
  if the monikette is nil, exit.
  void the routine.
  privatize the moniker.
  put the monikette's type into the monikette's current type.
  slap the monikette's current substring on the monikette's string.
  loop.
  append the monikette to the moniker (while bubbling).
  find a refer given the moniker and the index.
  if the refer is not nil, put the refer's pointer into the routine.
  if the refer is not nil, find the routine given the moniker and the monikette's next and the index.
  if the routine is not nil, break.
  bubble the monikette.
  if the monikette is bubbled out, break.
  put the original moniker into the moniker.
  repeat.

to find a routine given some monikettes:
  void the routine.
  find the routine given a moniker and the monikettes' first and the routine index.

to find a routine given a string and another string and a third string and a fourth string:
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the other string.
  add a third monikette to the monikettes given the third string.
  add a fourth monikette to the monikettes given the fourth string.
  find the routine given the monikettes.
  destroy the monikettes.

to find a routine given a string and a type:
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the type.
  find the routine given the monikettes.
  destroy the monikettes.

to find a routine given a string and a type and another string and another type:
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the type.
  add a third monikette to the monikettes given the other string.
  add a fourth monikette to the monikettes given the other type.
  find the routine given the monikettes.
  destroy the monikettes.

to find a routine given a string and a type and another string and a third string:
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the type.
  add a third monikette to the monikettes given the other string.
  add a fourth monikette to the monikettes given the third string.
  find the routine given the monikettes.
  destroy the monikettes.

to find a routine given a string and a type and another string and a third string and a fourth string and a fifth string:
  add a monikette to some monikettes given the string.
  add another monikette to the monikettes given the type.
  add a third monikette to the monikettes given the other string.
  add a fourth monikette to the monikettes given the third string.
  add a fifth monikette to the monikettes given the fourth string.
  add a sixth monikette to the monikettes given the fifth string.
  find the routine given the monikettes.
  destroy the monikettes.

to find a row# given a source file and a byte pointer:
  if the byte pointer is nil, put 0 into the row#; exit.
  slap a substring on the source file's buffer.
  put 1 into the row#.
  loop.
  if the substring is blank, exit.
  if the substring's first is the byte pointer, exit.
  if the substring's first's target is the return byte, add 1 to the row#.
  add 1 to the substring's first.
  repeat.

to find a source file given a byte pointer:
  if the byte pointer is nil, void the source file; exit.
  loop.
  get the source file from the source files.
  if the source file is nil, exit.
  if the byte pointer is less than the source file's buffer's first, repeat.
  if the byte pointer is greater than the source file's buffer's last, repeat.

to find a type and a nickname given a name:
  void the type.
  clear the nickname.
  slap a substring on the name.
  loop.
  if the substring is blank, exit.
  find the type given the substring and the type index.
  if the type is not nil, break.
  skip to the next word in the substring.
  repeat.
  put the name's first into another substring's first.
  put the substring's first minus 2 into the other substring's last.
  if the other substring is not blank, put the other substring into the nickname.
  if the other substring is blank, put the substring into the nickname.

to find a variable given a name:
  if the current routine is nil, void the variable; exit.
  find the variable given the name and the current routine's locals.
  if the variable is not nil, exit.
  find the variable given the name and the current routine's parameters.
  if the variable is not nil, exit.
  find the variable given the name and the global index.
  if the variable is not nil, exit.
  find the variable given the name and the literal index.

to find a variable given a name and some variables:
  void the variable.
  loop.
  get the variable from the variables.
  if the variable is nil, exit.
  if the variable's name is the name, exit.
  if the variable's nickname is the name, exit.
  repeat.

a fragment is a thing with
  a tag [break, call external, call indirect, call internal, dereference, end if, epilog, exit, finalize, increment, intel, jump false, load address, load eax, loop, not, prolog, push address, push value, save eax, repeat, routine address],
  a variable (reference) [call indirect, dereference, increment, load address, load eax, pop, push address, push value, routine address, save eax],
  another variable (reference) [load address],
  a routine (reference) [call internal, routine address],
  an entry (reference) [call external],
  a number [increment],
  an address,
  a hex string called code.

to generate a name given a string:
  put the string into the name.
  add 1 to the compiler's name count.
  convert the compiler's name count to another string.
  append the other string to the name.

to get an address given a routine:
  if the routine's address is not 0, put the routine's address into the address; exit.
  put -1 into the routine's address.
  find another routine given the routine's employs moniker and the routine index.
  if the other routine is nil, abort with "I can't find the '" then the routine's employs moniker then "' routine you're trying to employ." and the routine's locus; exit.
  if the other routine's address is -1, abort with "Recursive reference in employ clause." and the routine's locus; exit.
  get the address given the other routine.
  put the address into the routine's address.

to get a count given some imports (all entries plus markers):
  put 0 into the count.
  loop.
  get an import from the imports.
  if the import is nil, exit.
  add the import's entries' count to the count.
  add 1 to the count.
  repeat.

a global body is a substring.

the global index is an index.

a global is a variable.

the globals are some globals.

the image base is an address equal to 4194304 [$00400000].

the import borough is a borough.

an import header is a record with
  an address called original first thunk,
  a number called timestamp,
  an address called forwarder chain,
  an address called name memory address,
  an address called first thunk memory address.

an import is a thing with
  a name address,
  a header address,
  a name,
  an import header,
  some entries.

the imports are some imports.

the increment tag is a tag equal to 10.

to index a global:
  if the compiler's abort flag is set, exit.
  if the global is nil, exit.
  if the global's name is in the global index, abort with "'" then the global's name then "' is a duplicate global variable." and the global's locus; exit.
  index the global given the global's name and the global index.

to index a literal:
  if the compiler's abort flag is set, exit.
  if the literal is nil, exit.
  if the literal's name is in the literal index, abort with "Internal error - index a literal" and the literal's locus; exit.
  index the literal given the literal's name and the literal index.

to index a partial moniker given an index (special):
  find a refer given the partial moniker and the index.
  if the refer is not nil, exit.
  index the partial moniker in the index.

to index a routine for utility use:
  if the compiler's abort flag is set, exit.
  if the routine is nil, exit.
  if the routine's function flag is set, exit.
  if the routine's parameters' count is 0, exit.
  copy the routine's monikettes into some monikettes.
  reduce the monikettes for utility use.
  convert the monikettes to a moniker.
  destroy the monikettes.
  if the moniker is in the routine index, exit.
  find a refer given the moniker and the utility index.
  if the refer is not nil, put nil into the refer's pointer; exit.
  index the routine given the moniker and the utility index.

to index a routine given a moniker and an index (special):
  find a refer given the moniker and the index.
  if the refer is not nil, put the routine into the refer's pointer; exit.
  index the routine given the moniker and the index.

to index a routine given some monikettes and an index:
  if the routine is nil, exit.
  clear a partial moniker.
  loop.
  get a monikette from the monikettes.
  if the monikette is nil, exit.
  append the monikette to the partial moniker.
  if the monikette is the monikettes' last, break.
  index the partial moniker given the index (special).
  repeat.
  index the routine given the partial moniker as a moniker and the index (special).

to index some routines for utility use:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, exit.
  index the routine for utility use.
  repeat.

to index a type:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  index the type given the type's name.

to index a type given a name:
  if the type is nil, exit.
  if the compiler's abort flag is set, exit.
  find an existing type given the name and the type index.
  if the existing type is nil, index the type given the name and the type index; exit.
  put the type's locus into a locus.
  if the locus is nil, put the existing type's locus into the locus. \ point the error to a type in the source code, not a generated type
  abort with "I think I've seen this '" then the name then "' type somewhere before; it must be a duplicate." and the locus.

the indexing utilities timer is a timer.

to initialize the compiler:

to initialize the compiler given a directory:
  put the directory into the compiler's directory.
  put 0 into the compiler's name count.
  clear the compiler's abort flag.
  clear the compiler's abort message.
  clear the compiler's abort path.
  put 0 into the compiler's abort row#.
  void the current routine.
  create the type index given 4027.
  create the global index given 4027.
  create the literal index given 4027.
  create the routine index given 7919.
  create the utility index given 4027.

to initialize a dos header:
  put 23117 [$5A4D] into the dos header's signature.
  put 64 [$0040] into the dos header's addressofrelocationtableinfile.
  put 256 [$00000100] into the dos header's addressofpeheaderinfile.

to initialize a pe header:
  initialize the pe header (standard header).
  initialize the pe header (optional header).
  initialize the pe header (version information).
  initialize the pe header (directories).
  initialize the pe header (import section).
  initialize the pe header (data section).
  initialize the pe header (code section).

to initialize a pe header (code section):
  copy bytes from "code  "'s first to the pe header's code section's name's whereabouts for 6.
  put the code borough's length into the pe header's code section's sizeinbytes.
  put the code borough's base into the pe header's code section's addressinmemory.
  put the code borough's length into the pe header's code section's sizeinfile.
  put the code borough's base into the pe header's code section's addressinfile.
  put -536870880 [$E0000020] into the pe header's code section's characteristics. \ executable, readable, writable, code object

to initialize a pe header (data section):
  copy bytes from "data  "'s first to the pe header's data section's name's whereabouts for 6.
  put the data borough's length into the pe header's data section's sizeinbytes.
  put the data borough's base into the pe header's data section's addressinmemory.
  put the data borough's length into the pe header's data section's sizeinfile.
  put the data borough's base into the pe header's data section's addressinfile.
  put -1073741760 [$C0000040] into the pe header's data section's characteristics. \ initialized, readable, writable

to initialize a pe header (directories):
  put 16 [$00000010] into the pe header's numberofdirectories.
  put the import borough's base into the pe header's imagedirectoryentryimportaddress.
  put the import borough's length into the pe header's imagedirectoryentryimportsize.

to initialize a pe header (import section):
  copy bytes from "idata "'s first to the pe header's idata section's name's whereabouts for 6.
  put the import borough's length into the pe header's idata section's sizeinbytes.
  put the import borough's base into the pe header's idata section's addressinmemory.
  put the import borough's length into the pe header's idata section's sizeinfile.
  put the import borough's base into the pe header's idata section's addressinfile.
  put -1073741760 [$C0000040] into the pe header's idata section's characteristics. \ initialized, readable, writable

to initialize a pe header (optional header):
  put 267 [$010B] into the pe header's magicnumber.
  put the code borough's length into the pe header's sizeofcodeinfile.
  put the data borough's length into the pe header's sizeofinitializeddatainfile.
  put 0 into the pe header's sizeofuninitializeddatainfile.
  find a routine given "~initialize before run and run and finalize after run" and the routine index.
  if the routine is nil, abort with "Internal error: could not find the startup routine"; exit.
  put the routine's address minus the image base into the pe header's addressofentrypointinmemory.
  put the code borough's base into the pe header's addressofcodeinmemory.
  put the data borough's base into the pe header's addressofinitializeddatainmemory.
  put the image base into the pe header's imagebase.
  put 4096 [$00001000] into the pe header's memoryalignment.
  put 4096 [$00001000] into the pe header's filealignment.
  put 0 into the pe header's reserved.
  put the compiler's exe size into the pe header's sizeofimageinmemory.
  put 4096 [section base] into the pe header's sizeofallheadersinfile.
  put 0 into the pe header's checksum.
  put 0 into the pe header's dllcharacteristics.
  put 1048576 [$00100000] into the pe header's maxstack.
  put 16384 [$00004000] into the pe header's minstack.
  put 1048576 [$00100000] into the pe header's maxheap.
  put 16384 [$00004000] into the pe header's minheap.
  put 0 into the pe header's loaderflags.

to initialize a pe header (standard header):
  put 17744 [$00004550] into the pe header's signature.
  put 332 [$014C] into the pe header's machinetype.
  put 3 [$0003] into the pe header's numberofsections.
  put 0 into the pe header's timestamp.
  put 0 into the pe header's pointertosymboltable.
  put 0 into the pe header's numberofsymbols.
  put 224 [$00E0] into the pe header's sizeofoptionalheaderinbytes.
  put 33166 [$818E] into the pe header's characteristics.

to initialize a pe header (version information):
  put 0 into the pe header's majorlinkerversion.
  put 0 into the pe header's minorlinkerversion.
  put 4 [$0004] into the pe header's osmajorversion.
  put 0 [$0000] into the pe header's osminorversion.
  put 0 into the pe header's usermajorversion.
  put 0 into the pe header's userminorversion.
  put 4 [$0004] into the pe header's subsystemmajorversion.
  put 0 [$0000] into the pe header's subsystemminorversion.
  put 2 [$0002] into the pe header's subsystem.

the intel tag is a tag equal to 11.

an intermediate is a local.

the jump false tag is a tag equal to 12.

to link:
  round up borough sizes.
  initialize a dos header.
  initialize a pe header.
  fill the compiler's exe with the null byte given the compiler's exe size.
  blurt the dos header into the compiler's exe.
  blurt the pe header into the compiler's exe.
  blurt the imports into the compiler's exe.
  blurt the globals into the compiler's exe.
  blurt the literals into the compiler's exe.
  blurt the routines into the compiler's exe.

the linking timer is a timer.

to list:
  clear the compiler's listing.
  list the compiler's abort message in the compiler's listing.
  list the types under "TYPES:" in the compiler's listing.
  list the globals under "GLOBALS:" in the compiler's listing.
  list the literals under "LITERALS:" in the compiler's listing.
  list the routines under "ROUTINES:" in the compiler's listing.
  list the type index under "TYPE INDEX:" in the compiler's listing.
  list the global index under "GLOBAL INDEX:" in the compiler's listing.
  list the literal index under "LITERAL INDEX:" in the compiler's listing.
  list the routine index under "ROUTINE INDEX:" in the compiler's listing.
  list the utility index under "UTILITY INDEX:" in the compiler's listing.
  list the imports under "IMPORTS:" in the compiler's listing.
  list the source files under "SOURCE FILES:" in the compiler's listing.
  list the timers under "TIMERS:" in the compiler's listing.
  write the compiler's listing to the compiler's listing path.

to list an abort message in a buffer:
  if the abort message is blank, exit.
  append "COMPILE ABORTED - LISTING INCOMPLETE" to the buffer.
  advance the buffer (twice).
  append the abort message to the buffer.
  advance the buffer (twice).

to list a bucket in a buffer:
  if the bucket's refers are empty, exit.
  append "/bucket" to the buffer (with separator).
  advance the buffer.
  list the bucket's refers in the buffer.
  advance the buffer.

to list some entries in a buffer:
  get an entry from the entries.
  if the entry is nil, exit.
  list the entry in the buffer.
  repeat.

to list an entry in a buffer:
  if the entry is nil, exit.
  append "/entry" to the buffer (with separator).
  append the entry's name to the buffer (with separator).
  append the entry's address to the buffer (as hex with separator).
  advance the buffer.

to list a fragment in a buffer:
  append "/fragment" to the buffer (with separator).
  append the fragment's tag to the buffer (as a fragment tag string with separator).
  append the fragment's variable to the buffer (with separator).
  append the fragment's other variable to the buffer (with separator).
  append the fragment's routine to the buffer (with separator).
  append the fragment's entry to the buffer (with separator).
  append the fragment's number to the buffer (as hex with separator).
  append the fragment's address to the buffer (as hex with separator).
  convert the fragment's code to a nibble string.
  append the nibble string to the buffer (with separator).
  advance the buffer.

to list some fragments in a buffer:
  get a fragment from the fragments.
  if the fragment is nil, exit.
  list the fragment in the buffer.
  repeat.

to list an import in a buffer:
  if the import is nil, exit.
  append "/import" to the buffer (with separator).
  append the import's name to the buffer (with separator).
  advance the buffer.
  list the import's entries in the buffer.
  advance the buffer.

to list some imports in a buffer:
  get an import from the imports.
  if the import is nil, exit.
  list the import in the buffer.
  repeat.

to list some imports under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the imports are empty, exit.
  list the imports in the buffer.

to list an index in a buffer:
  append "/" then the index's used bucket count then " buckets" to the buffer (with separator).
  append the index's count then " refers" to the buffer (with separator).
  advance the buffer (twice).
  loop.
  get a bucket given the index.
  if the bucket is nil, exit.
  list the bucket in the buffer.
  repeat.

to list an index under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the index is empty, exit.
  list the index in the buffer.

to list a refer in a buffer:
  if the refer is nil, exit.
  append "/refer" to the buffer (with separator).
  append the refer's string to the buffer.
  if the refer's pointer is nil, append "..." to the buffer.
  append "/" to the buffer.
  advance the buffer.

to list some refers in a buffer:
  get a refer from the refers.
  if the refer is nil, exit.
  list the refer in the buffer.
  repeat.

to list a routine in a buffer:
  if the routine is nil, exit.
  append "/routine" to the buffer (with separator).
  append the routine's moniker to the buffer (with separator).
  append the routine's compiled flag to the buffer (with separator).
  append the routine's callback flag to the buffer (with separator).
  append the routine's decider flag to the buffer (with separator).
  append the routine's function flag to the buffer (with separator).
  append the routine's employs moniker to the buffer (with separator).
  append the routine's parameter size to the buffer (with separator).
  append the routine's local size to the buffer (with separator).
  append the routine's address to the buffer (as hex with separator).
  advance the buffer.
  list the routine's parameters in the buffer.
  list the routine's locals in the buffer.
  list the routine's fragments in the buffer.
  advance the buffer.

to list some routines in a buffer:
  get a routine from the routines.
  if the routine is nil, exit.
  list the routine in the buffer.
  repeat.

to list some routines under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the routines are empty, exit.
  list the routines in the buffer.

to list a source file in a buffer:
  if the source file is nil, exit.
  append "/source file" to the buffer (with separator).
  append the source file's path to the buffer (with separator).
  advance the buffer.

to list some source files in a buffer:
  get a source file from the source files.
  if the source file is nil, exit.
  list the source file in the buffer.
  repeat.

to list some source files under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the source files are empty, exit.
  list the source files in the buffer.
  advance the buffer.

to list a timer given a string in a buffer:
  append "/timer" to the buffer (with separator).
  append the string to the buffer (with separator).
  append the timer's string to the buffer (with separator).
  advance the buffer.

to list the timers under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  list the reading timer given "reading" in the buffer.
  list the scanning timer given "scanning" in the buffer.
  list the resolving types timer given "resolving types" in the buffer.
  list the resolving globals timer given "resolving globals" in the buffer.
  list the compiling routine headers timer given "compiling routine headers" in the buffer.
  list the calculating timer given "calculating" in the buffer.
  list the adding built-in memory routines timer given "adding built-in memory routines" in the buffer.
  list the indexing utilities timer given "indexing utilities" in the buffer.
  list the compiling routine bodies timer given "compiling routine bodies" in the buffer.
  list the adding built-in startup routine timer given "adding built-in startup routine" in the buffer.
  list the offsetting timer given "offsetting" in the buffer.
  list the addressing timer given "addressing" in the buffer.
  list the transmogrifying timer given "transmogrifying" in the buffer.
  list the linking timer given "linking" in the buffer.
  list the writing timer given "writing" in the buffer.
  list the compiler's timer given "total" in the buffer.
  advance the buffer.

to list a type in a buffer:
  if the type is nil, exit.
  append "/type" to the buffer (with separator).
  append the type's name to the buffer (with separator).
  append the type's plural name to the buffer (with separator).
  append the type's length to the buffer (as hex with separator).
  append the type's base name to the buffer (with separator).
  append the type's base type to the buffer (with separator).
  append the type's target name to the buffer (with separator).
  append the type's target type to the buffer (with separator).
  append the type's scale to the buffer (with separator).
  advance the buffer.
  list the type's fields in the buffer.
  advance the buffer.

to list some types in a buffer:
  get a type from the types.
  if the type is nil, exit.
  list the type in the buffer.
  repeat.

to list some types under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the types are empty, exit.
  list the types in the buffer.

to list a variable in a buffer:
  if the variable is nil, exit.
  append "/variable" to the buffer (with separator).
  append the variable's kind to the buffer (with separator).
  append the variable's compiled flag to the buffer (with separator).
  append the variable's name to the buffer (with separator).
  append the variable's nickname to the buffer (with separator).
  append the variable's type name to the buffer (with separator).
  append the variable's type to the buffer (with separator).
  append the variable's address [or offset] to the buffer (as hex with separator).
  append the variable's by-value flag to the buffer (with separator).
  append the variable's count to the buffer (with separator).
  append the variable's reference flag to the buffer (with separator).
  append the variable's redefinition target name to the buffer (with separator).
  append the variable's literal to the buffer (with separator).
  convert the variable's data to a nibble string.
  append the nibble string to the buffer (with separator).
  advance the buffer.

to list some variables in a buffer:
  get a variable from the variables.
  if the variable is nil, exit.
  list the variable in the buffer.
  repeat.

to list some variables under a string in a buffer:
  append the string to the buffer.
  advance the buffer (twice).
  if the variables are empty, exit.
  list the variables in the buffer.
  advance the buffer.

the literal index is an index.

a literal is a variable.

the literals are some literals.

the load address tag is a tag equal to 13.

the load eax tag is a tag equal to 14.

a local is a variable.

a locus is a byte pointer.

the loop tag is a tag equal to 15.

a moniker is a string.

a monikette is a thing with
  a string,
  a type (reference),
  a variable (reference),
  \ for bubbling
  a current type (reference),
  a current substring.

to move a rider (code rules - comment):
  bump the rider.
  if the rider's source is blank, exit.
  if the rider's source's first's target is not the return byte, repeat.

to move a rider (code rules - glom):
  bump the rider.
  if the rider's source is blank, exit.
  if the rider is on any possessive, exit.
  if the rider's source's first's target is any glom byte, repeat.

to move a rider (code rules - mark):
  bump the rider.

to move a rider (code rules - noise):
  bump the rider.
  if the rider's source is blank, exit.
  if the rider's source's first's target is noise, repeat.

to move a rider (code rules - possessive):
  bump the rider.
  if the rider's source is blank, exit.
  if the rider's source starts with "s", bump the rider.

to move a rider (code rules - qualifier):
  if the rider's source is blank, exit.
  if the rider's source's first's target is the return byte, break.
  if the rider's source's first's target is the left-paren byte, add 1 to a count.
  if the rider's source's first's target is the right-paren byte, subtract 1 from the count.
  bump the rider.
  if the count is 0, break.
  repeat.

to move a rider (code rules - remark):
  if the rider's source is blank, exit.
  if the rider's source's first's target is the return byte, break.
  if the rider's source's first's target is the left-bracket byte, add 1 to a count.
  if the rider's source's first's target is the right-bracket byte, subtract 1 from the count.
  bump the rider.
  if the count is 0, break.
  repeat.  

to move a rider (code rules - string):
  bump the rider.
  if the rider's source is blank, exit.
  if the rider's source's first's target is the return byte, exit.
  if the rider is on any nested double-quote, bump the rider; repeat.
  if the rider's source's first's target is the double-quote byte, bump the rider; exit.
  repeat.

to move a rider (code rules - symbol):
  bump the rider.

to move a rider (code rules):
  position the rider's token on the rider's source.
  if the rider's source is blank, exit.
  if the rider's source's first's target is noise, move the rider (code rules - noise); exit.
  if the rider's source's first's target is the backslash byte, move the rider (code rules - comment); exit.
  if the rider's source's first's target is the left-bracket byte, move the rider (code rules - remark); exit.
  if the rider's source's first's target is the double-quote byte, move the rider (code rules - string); exit.
  if the rider's source's first's target is the left-paren byte, move the rider (code rules - qualifier); exit.
  if the rider's source's first's target is any mark, move the rider (code rules - mark); exit.
  if the rider is on any possessive, move the rider (code rules - possessive); exit.
  move the rider (code rules - glom).

to move a rider (compiler rules):
  if the compiler's abort flag is set, clear the rider's token; exit.
  move the rider returning an error string (code rules).
  if the error string is not blank, abort with the error string and the rider's token's first; exit.
  if the rider's token is blank, exit.
  if the rider's token's first's target is noise, repeat.
  if the rider's token's first's target is the backslash byte, repeat.
  if the rider's token's first's target is the left-bracket byte, repeat.

to move a rider returning an error string (code rules - validate qualifier):
  if the rider's token's length is less than 2, put "Qualifiers need to end with ')'." into the error string; exit.
  if the rider's token's last's target is not the right-paren byte, put "Qualifiers need to end with ')'." into the error string; exit.

to move a rider returning an error string (code rules - validate remark):
  if the rider's token's length is less than 2, put "Remarks need to end with ']'." into the error string; exit.
  if the rider's token's last's target is not the right-bracket byte, put "Remarks need to end with ']'." into the error string; exit.

to move a rider returning an error string (code rules - validate string):
  if the rider's token's length is less than 2, put "Strings need to end with '""'." into the error string; exit.
  if the rider's token's last's target is not the double-quote byte, put "Strings need to end with '""'." into the error string; exit.

to move a rider returning an error string (code rules):
  clear the error string.
  move the rider (code rules).
  if the rider's token is blank, exit.
  if the rider's token's first's target is the left-bracket byte, move the rider returning the error string (code rules - validate remark); exit.
  if the rider's token's first's target is the double-quote byte, move the rider returning the error string (code rules - validate string); exit.
  if the rider's token's first's target is the left-paren byte, move the rider returning the error string (code rules - validate qualifier); exit.

a nibble substring is a substring.

a nickname is a name.

the not tag is a tag equal to 16.

to offset the locals in a routine:
  if the routine is nil, exit.
  if the routine's compiled flag is not set, exit.
  clear the routine's local size.
  loop.
  if the compiler's abort flag is set, exit.
  get a local from the routine's locals.
  if the local is nil, exit.
  if the local's previous is not nil, put the local's previous' offset into the local's offset.
  put the local's type's length into a length.
  if the local's kind is "scratch", put a pointer's magnitude into the length.
  round the length up to the nearest multiple of 4.
  subtract the length from the local's offset.
  add the length to the routine's local size.
  repeat.

to offset the locals in some routines:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, exit.
  offset the locals in the routine.
  repeat.

to offset the parameters in a routine:
  if the routine is nil, exit.
  if the routine's compiled flag is not set, exit.
  clear the routine's parameter size.
  loop.
  if the compiler's abort flag is set, exit.
  get a parameter from the routine's parameters.
  if the parameter is nil, exit.
  if the routine's callback flag is set, set the parameter's by-value flag.
  if the parameter's previous is nil, put 8 into the parameter's offset. \ skip the return address and saved ebp
  if the parameter's previous is not nil, put the parameter's previous' offset plus 4 into the parameter's offset. \ all parameters are 4 byte pointers or 4 byte values for callbacks
  add 4 to the routine's parameter size.
  repeat.

to offset the parameters in some routines:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, exit.
  offset the parameters in the routine.
  repeat.

the offsetting timer is a timer.

a parameter is a variable.

a partial moniker is a moniker.

a pe header is a record with
  a number called signature,
  a wyrd called machinetype,
  a wyrd called numberofsections,
  a number called timestamp,
  a number called pointertosymboltable,
  a number called numberofsymbols,
  a wyrd called sizeofoptionalheaderinbytes,
  a wyrd called characteristics,
  \ optional header
  a wyrd called magicnumber,
  a byte called majorlinkerversion,
  a byte called minorlinkerversion,
  a number called sizeofcodeinfile,
  a number called sizeofinitializeddatainfile,
  a number called sizeofuninitializeddatainfile,
  a number called addressofentrypointinmemory,
  a number called addressofcodeinmemory,
  a number called addressofinitializeddatainmemory,
  a number called imagebase,
  a number called memoryalignment,
  a number called filealignment,
  a wyrd called osmajorversion,
  a wyrd called osminorversion,
  a wyrd called usermajorversion,
  a wyrd called userminorversion,
  a wyrd called subsystemmajorversion,
  a wyrd called subsystemminorversion,
  a number called reserved,
  a number called sizeofimageinmemory,
  a number called sizeofallheadersinfile,
  a number called checksum,
  a wyrd called subsystem,
  a wyrd called dllcharacteristics,
  a number called maxstack,
  a number called minstack,
  a number called maxheap,
  a number called minheap,
  a number called loaderflags,
  \ directories (16 address and size pairs)
  a number called numberofdirectories,
  8 bytes called directory0,
  a number called imagedirectoryentryimportaddress,
  a number called imagedirectoryentryimportsize,
  112 bytes called directories2-15,
  a pe section header called idata section,
  a pe section header called data section,
  a pe section header called code section.

a pe section header is a record with
  8 bytes called name,
  a number called sizeinbytes,
  a number called addressinmemory,
  a number called sizeinfile,
  a number called addressinfile,
  12 bytes called reserved,
  a number called characteristics.

a phrase is a string.

to pluralize a string: \ nouns only
  if the string is "alumnus", put "alumni" into the string; exit.
  if the string is "auto", put "autos" into the string; exit.
  if the string is "cello", put "cellos" into the string; exit.
  if the string is "dwarf", put "dwarfs" into the string; exit.
  if the string is "foot", put "feet" into the string; exit.
  if the string is "genus", put "genera" into the string; exit.
  if the string is "goose", put "geese" into the string; exit.
  if the string is "hippo", put "hippos" into the string; exit.
  if the string is "louse", put "lice" into the string; exit.
  if the string is "memo", put "memos" into the string; exit.
  if the string is "mouse", put "mice" into the string; exit.
  if the string is "ox", put "oxen" into the string; exit.
  if the string is "phenomenon", put "phenomena" into the string; exit.
  if the string is "photo", put "photos" into the string; exit.
  if the string is "phylum", put "phyla" into the string; exit.
  if the string is "piano", put "pianos" into the string; exit.
  if the string is "pimento", put "pimentos" into the string; exit.
  if the string is "pro", put "pros" into the string; exit.
  if the string is "proof", put "proofs" into the string; exit.
  if the string is "radius", put "radii" into the string; exit.
  if the string is "rhinoceros", put "rhinoceri" into the string; exit.
  if the string is "roof", put "roofs" into the string; exit.
  if the string is "solo", put "solos" into the string; exit.
  if the string is "soprano", put "sopranos" into the string; exit.
  if the string is "staff", put "staffs" into the string; exit.
  if the string is "tooth", put "teeth" into the string; exit.
  if the string is "torus", put "tori" into the string; exit.
  if the string is "turf", put "turfs" into the string; exit.
  if the string is "virus", put "viruses" into the string; exit.
  if the string ends with "sh", append "es" to the string; exit.
  if the string ends with "ch", append "es" to the string; exit.
  if the string ends with "man", remove the last two bytes from the string; append "en" to the string; exit.
  if the string ends with "child", append "ren" to the string; exit.
  if the string ends with "ex", remove the last two bytes from the string; append "ices" to the string; exit. \ or add ES
  if the string ends with "fe", remove the last two bytes from the string; append "ves" to the string; exit.
  if the string ends with "is", remove the last two bytes from the string; append "es" to the string; exit.
  if the string ends with "ix", remove the last two bytes from the string; append "ices" to the string; exit. \ or add ES
  if the string ends with "ma", append "ta" to the string; exit. \ or add S
  if the string ends with any consonant and "y", remove the last byte from the string; append "ies" to the string; exit.
  if the string ends with any vowel and "o", append "s" to the string; exit.
  if the string ends with any vowel and "y", append "s" to the string; exit.
  if the string ends with "f", remove the last byte from the string; append "ves" to the string; exit.
  if the string ends with "s", append "es" to the string; exit.
  if the string ends with "x", append "es" to the string; exit.
  if the string ends with "z", append "es" to the string; exit.
  append "s" to the string.

the prolog tag is a tag equal to 17.

a prototype string has a first byte pointer and a last byte pointer.

the push address tag is a tag equal to 18.

the push value tag is a tag equal to 19.

to put the compiler's exe path into a path:
  extract a designator from the compiler's directory.
  remove any trailing backslash from the designator.
  put the compiler's directory then the designator then ".exe" into the path.

to put the compiler's exe size into a size:
  put 4096 [section base] into the size.
  add the import borough's size to the size.
  add the data borough's size to the size.
  add the code borough's size to the size.

to put the compiler's listing path into a path:
  extract a designator from the compiler's directory.
  remove any trailing backslash from the designator.
  put the compiler's directory then the designator then ".lst" into the path.

to put a term into another term:
  put the term's variable into the other term's variable.
  put the term's phrase into the other term's phrase.

to read a source file:
  if the source file is nil, exit.
  read the source file's path into the source file's buffer.
  if the i/o error is not blank, abort with "Could not read the file named '" then the source file's path then "'."; exit.

to read some source files:
  loop.
  if the compiler's abort flag is set, exit.
  get an item from the compiler's directory.
  if the item is not found, break.
  if the item's kind is not "file", repeat.
  if the item's extension is not blank, repeat.
  add a source file to the source files given the item's path.
  read the source file.
  repeat.

the reading timer is a timer.

to reduce some monikettes for utility use:
  get a monikette from the monikettes.
  if the monikette is nil, exit.
  if the monikette's type is nil, repeat.
  reduce the monikette's type to a type for utility use.
  if the type is not nil, put the type into the monikette's type.
  repeat.

to reduce a type to another type for utility use:
  put the type into the other type.
  loop.
  if the other type is nil, exit.
  if the other type's name is "hex string", exit.
  if the other type's name is "string", exit.
  if the other type's name is "number", exit.
  if the other type's name is "pointer", exit.
  if the other type's name is "thing", void the other type; exit.
  if the other type's base type is the other type, void the other type; exit.
  put the other type's base type into the other type.
  repeat.

to reindex the utility index:
  if the compiler's abort flag is set, exit.
  get a bucket given the utility index.
  if the bucket is nil, exit.
  if the bucket's refers are empty, repeat.
  reindex the utility index given the bucket's refers.
  repeat.

to reindex the utility index given some refers:
  get a refer from the refers.
  if the refer is nil, exit.
  put the refer's pointer into a routine.
  if the routine is nil, abort with "Internal error - index the untility routines given some refers"; exit.
  copy the routine's monikettes into some monikettes.
  reduce the monikettes for utility use.
  index the routine given the monikettes and the routine index.
  destroy the monikettes.
  repeat.

to remove any negatives from some monikettes returning a flag:
  clear the flag.
  swap the monikettes with some other monikettes.
  loop.
  put the other monikettes' first into a monikette.
  if the monikette is nil, exit.
  remove the monikette from the other monikettes.
  if the monikette's string is "not", reverse the flag; destroy the monikette; repeat.
  append the monikette to the monikettes.
  if the monikette's string is "cannot", reverse the flag; put "can" into the monikette's string; repeat.
  if the monikette's string is "nothing", reverse the flag; put "something" into the monikette's string; repeat.
  if the monikette's string is "won't", reverse the flag; put "will" into the monikette's string; repeat.
  if the monikette's string ends with "n't", reverse the flag; remove trailing bytes from the monikette's string given 3; repeat.
  repeat.

the repeat tag is a tag equal to 21.

to resolve a field:
  if the compiler's abort flag is set, exit.
  if the field is nil, exit.
  resolve the field as a variable.
  if the field's nickname is not any valid field name, clear the field's nickname.
  if the field's name is not any valid field name, abort with "'" then the field's name then "' is not a valid field name." and the field's locus; exit.

to resolve a global:
  if the global is nil, exit.
  if the compiler's abort flag is set, exit.
  if the global's global body is not blank, resolve the global (compile body).
  if the global's type name is blank, abort with "Invalid global '" then the global's name then "'." and the global's locus; exit.
  resolve the global as a variable.

to resolve a global (compile body):
  if the global is nil, exit.
  if the compiler's abort flag is set, exit.
  slap a rider on the global's global body.
  move the rider (compiler rules).
  if the rider's token is not any literal, abort with "I need a literal here, but I found '" then the rider's token then "'." and the rider; exit.
  compile a literal given the rider.
  if the compiler's abort flag is set, exit.
  if the rider's token is not blank, abort with "Is a period missing around here?" and the rider; exit.
  if the global's type name is blank, put the literal's type's name into the global's type name.
  put the literal into the global's literal.
  index the literal.

to resolve some globals:
  if the compiler's abort flag is set, exit.
  get a global from the globals.
  if the global is nil, exit.
  resolve the global.
  repeat.

to resolve a type (base type):
  if the compiler's abort flag is set, exit.
  if the type is nil, exit.
  if the type's base type is not nil, exit.
  find the type's base type given the type's base name and the type index.
  if the type's base type is nil, abort with "Invalid base type '" then the type's base name then "'." and the type's locus; exit.
  set the type's cooking flag.
  if the type's base type's cooking flag is set, abort with "Recursive definition with '" then the type's base name then "'." and the type's locus; exit.
  resolve the type's base type (base type).
  clear the type's cooking flag.

to resolve a type (expand thing): \ type's base type is not resolved yet
  if the compiler's abort flag is set, exit.
  if the type is nil, exit.
  if the type's base type is not nil, exit.
  if the type's name is "thing", exit.
  if the type cannot be reduced to "thing" using the base name, exit.
  find a base type given the type's base name and the type index.
  \  add thing record
  put the type's name then " record" into a name.
  put the type's name then " records" into a plural name.
  put the base type's name then " record" into a base name.
  add a record type to the types given the name and the plural name and the base name.
  add a field to the record type's fields given "next " then the type's name and "next" and the type's name and yes.
  add another field to the record type's fields given "previous " then the type's name and "previous" and the type's name and yes.
  if the type's fields are not empty, append the type's fields to the record type's fields.
  index the record type.
  \ fix up original type to look like a pointer
  put the record type's name into the type's target name.
  \ add chain type
  add a chain type to the types given the type's plural name and "" and the base type's plural name.
  add a third field to the chain type's fields given "first " then the type's name and "first" and the type's name and yes.
  add a fourth field to the chain type's fields given "last " then the type's name and "last" and the type's name and yes.
  index the chain type.

to resolve a type (index plural):
  if the compiler's abort flag is set, exit.
  if the type is nil, exit.
  if the type's plural name is blank, exit.
  if the type can be reduced to "thing" using the base name, exit.
  index the type given the type's plural name.

to resolve a type (optional info - pointer):
  if the compiler's abort flag is set, exit.
  if the type's target type is not nil, exit.
  if the type's target name is blank, put the type's base type's target type into the type's target type; exit.
  find the type's target type given the type's target name and the type index.
  if the type's target type is nil, abort with "I can't quite see what you're pointing at. Please clarify." and the type's locus; exit.

to resolve a type (optional info - record):
  if the compiler's abort flag is set, exit.
  if the type's fields are empty, copy the type's base type's fields into the type's fields; exit.
  loop.
  if the compiler's abort flag is set, exit.
  get a field from the type's fields (backwards).
  if the field is nil, break.
  if the field is duplicated in the type's fields, abort with "The '" then the field's name then "' field is defined more than once." and the field's locus; exit.
  resolve the field.
  if the compiler's abort flag is set, exit.
  if the field's type's cooking flag is set, abort with "Recursive definition with '" then the field's type's name then "'." and the field's locus; exit.
  resolve the field's type (optional info).
  if the field's reference flag is not set, repeat.
  if the field's type cannot be reduced to "pointer", abort with "Exactly what do you mean by '(reference)' here on this '" then the field's name then "'?" and the field's locus; exit.
  repeat.
  eliminate duplicate nicknames from the type's fields.
  if the type cannot be reduced to "thing record", exit.
  if the type's fields' count is greater than 2, exit.
  copy the type's base type's fields into the type's fields (data fields only).

to resolve a type (optional info - scale):
  if the compiler's abort flag is set, exit.
  put the type's base type into a base type.
  if the type's scale is 0, put the type's base type's scale into the type's scale; exit.
  if the base type's scale is 0, exit.
  multiply the type's scale by the base type's scale.
  put the base type's base type into the type's base type.

to resolve a type (optional info):
  if the compiler's abort flag is set, exit.
  if the type is nil, exit.
  if the type's optional info resolved flag is set, exit.
  if the type's base type is the type, exit. \ for built in types
  check for invalid optional info on the type.
  set the type's cooking flag.
  resolve the type's base type (optional info).
  if the type can be reduced to "pointer", resolve the type (optional info - pointer).
  if the type can be reduced to "record", resolve the type (optional info - record).
  if the type can be reduced to "number", resolve the type (optional info - scale).
  clear the type's cooking flag.
  set the type's optional info resolved flag.

to resolve some types (base types):
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  resolve the type (base type).
  repeat.

to resolve some types (expand things):
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  resolve the type (expand thing).
  repeat.

to resolve some types (index plurals):
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  resolve the type (index plural).
  repeat.

to resolve some types (optional info):
  if the compiler's abort flag is set, exit.
  get a type from the types.
  if the type is nil, exit.
  resolve the type (optional info).
  repeat.

to resolve a variable:
  if the compiler's abort flag is set, exit.
  if the variable is nil, exit.
  if the variable's type is not nil, exit.
  if the variable's type name is not blank, resolve the variable (explicit type name); exit.
  find the variable's type and the variable's nickname given the variable's name.
  if the variable's type is not nil, put the variable's type's name into the variable's type name; exit.
  abort with "I can't find the '" then the variable's name then "' type." and the variable's locus.

to resolve a variable (explicit type name):
  find the variable's type given the variable's type name and the type index.
  if the variable's type is nil, abort with "I can't find the '" then the variable's type name then "' type." and the variable's locus; exit.

the resolving globals timer is a timer.

the resolving types timer is a timer.

to round up borough sizes:
  put the import borough's length into the import borough's size.
  round the import borough's size up to the nearest multiple of 4096.
  put the data borough's length into the data borough's size.
  round the data borough's size up to the nearest multiple of 4096.
  put the code borough's length into the code borough's size.
  round the code borough's size up to the nearest multiple of 4096.

the routine address tag is a tag equal to 22.

a routine body is a substring.

a routine header is a substring.

the routine index is an index.

a routine is a thing with
  a locus (reference),
  a callback flag,
  a decider flag,
  a function flag,
  a compiled flag,
  a nickname index,
  a moniker, some monikettes, some parameters, a parameter size,
  an employs moniker,
  some locals, a local size,
  a routine header, a header string,
  a routine body, a body string,
  some fragments,
  an address.

a routine reference is some monikettes.

the routines are some routines.

the save eax tag is a tag equal to 20.

to scan any optional info for a type given a rider:
    if the compiler's abort flag is set, exit.
  if the rider's token is "to", scan any optional info for the type given the rider (pointer); exit.
  if the rider's token is "with", scan any optional info for the type given the rider (record); exit.

to scan any optional info for a type given a rider (pointer):
  move the rider (compiler rules).
  if the rider's token is not any indefinite article, abort with "The 'to' here needs to be followed by an indefinite article, not '" then the rider's token then "'." and the rider; exit. 
  move the rider (compiler rules).
  scan the type's target name given the rider.

to scan any optional info for a type given a rider (record):
  move the rider (compiler rules).
  scan the type's fields given the rider.

to scan any pauses given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is not any pause, exit.
  move the rider (compiler rules).
  repeat.

to scan a field given a rider:
  if the compiler's abort flag is set, exit.
  scan the field given the rider (type part).
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is "called", scan the field given the rider (called part); repeat.
  if the rider's token is "at", scan the field given the rider (redefine part); repeat.
  if the rider's token is "(reference)", scan the field given the rider (reference part); repeat.

to scan a field given a rider (called part):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the field's type name is blank, put the field's name into the field's type name. \ byte array type name already filled in
  scan the field's name given the rider.

to scan a field given a rider (redefine part):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the rider's token is not "the", abort with "I was expecting the word 'the', but found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  scan the field's redefinition target name given the rider.

to scan a field given a rider (reference part):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  set the field's reference flag.

to scan a field given a rider (type part - byte array):
  if the compiler's abort flag is set, exit.
  convert the rider's token to a ratio.
  reduce the ratio.
  if the ratio's denominator is not 1, abort with "You have to specify a whole number of bytes for a byte array" and the rider; exit.
  put the ratio's numerator into the field's count.
  move the rider (compiler rules).
  if the rider's token is not "byte" or "bytes", abort with "Nothing but the word 'bytes' is appropriate after a counted field designator." and the rider; exit.
  move the rider (compiler rules).
  put "byte" into the field's type name.

to scan a field given a rider (type part - normal):
  if the compiler's abort flag is set, exit.
  if the rider's token is not any indefinite article, abort with "I was expecting an indefinite article, but found '" then the rider's token then "'." and the rider; exit.
  if the rider's token is "another", put "other" into the field's name.
  move the rider (compiler rules).
  scan a name given the rider.
  extend the field's name with the name.

to scan a field given a rider (type part):
  if the compiler's abort flag is set, exit.
  if the rider's token is any numeric literal, scan the field given the rider (type part - byte array); exit.
  scan the field given the rider (type part - normal).

to scan some fields given a rider:
  if the compiler's abort flag is set, exit.
  add a field to the fields given "field" and the rider's token's first.
  scan the field given the rider.
  if the rider's token is not any pause, exit.
  scan any pauses given the rider.
  repeat.

to scan a global body given a rider:
  if the compiler's abort flag is set, exit.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  put the rider's token's first into the global body's first.
  put -1 into the global body's last.
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is the colon byte, exit.
  if the rider's token is the period byte, exit.
  put the rider's token's last into the global body's last.
  move the rider (compiler rules).
  repeat.

to scan a global given a rider:
  if the compiler's abort flag is set, exit.
  add the global to the globals given "global" and the rider's token's first.
  move the rider (compiler rules).
  scan the global's name given the rider.
  if the rider's token is "has" or "have", scan the global given the rider (has or have); exit.
  if the rider's token is not "is" or "are", abort with "Geez. I need an 'is' or an 'are' hereabouts, but all I found was '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  if the rider's token is not any indefinite article, scan the global given the rider (literal term); exit.
  move the rider (compiler rules).
  scan the global's type name given the rider.  
  if the rider's token is the start of any optional info, scan the global given the rider (optional info); exit.
  if the rider's token is "equal", scan the global given the rider (data part); exit.
  if the rider's token is not the period byte, abort with "All global definitions must end with a period. Including this one." and the rider; exit. 
  move the rider (compiler rules).
  index the global.

to scan a global given a rider (data part):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  if the rider's token is not "to", abort with "I need the word 'to' after the word 'equal', not '" then the rider's token then "'." and the rider; exit. 
  move the rider (compiler rules).
  scan the global's global body given the rider.
  if the rider's token is not the period byte, abort with "All global definitions must end with a period. Including this one." and the rider; exit. 
  move the rider (compiler rules).
  index the global.

to scan a global given a rider (has or have):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  put "~inline " then the global's name then " type" into a name.
  put the name then "s" into a plural name.
  add a type to the types given the name and the plural name and "record" and the global's locus.
  index the type.
  put the type's name into the global's type name.
  scan the type's fields given the rider.
  if the rider's token is not the period byte, abort with "Your punctuation is bad here." and the rider; exit. 
  move the rider (compiler rules).
  index the global.

to scan a global given a rider (literal term):
  if the compiler's abort flag is set, exit.
  scan the global's global body given the rider.
  if the rider's token is not the period byte, abort with "All global definitions must end with a period. Including this one." and the rider; exit. 
  move the rider (compiler rules).
  index the global.

to scan a global given a rider (optional info):
  if the compiler's abort flag is set, exit.
  put "~inline " then the global's name then " type" into a name.
  put the name then "s" into a plural name.
  add a type to the types given the name and the plural name and the global's type name and the global's locus.
  index the type.
  put the type's name into the global's type name.
  scan any optional info for the type given the rider.
  if the rider's token is not the period byte, abort with "All global definitions must end with a period. Including this one." and the rider; exit. 
  move the rider (compiler rules).
  index the global.

to scan a name given a rider:
  clear the name.
  if the compiler's abort flag is set, exit.
  if the rider's token is any name starter, extend the name with the rider's token; move the rider (compiler rules).
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is any name ender, break.
  extend the name with the rider's token.
  move the rider (compiler rules).
  repeat.
  if the name is blank, abort with "I was kind of hoping for a name around here, but I found '" then the rider's token then "'." and the rider; exit.

to scan a routine body given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is the start of any definition, exit.
  put the rider's token's first into the routine body's first.
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  put the rider's token's last into the routine body's last.
  if the rider's token is the colon byte, abort with "You may have forgotten a period somewhere above this. You better check." and the rider; exit.
  if the rider's token is not the period byte, move the rider (compiler rules); repeat.
  move the rider (compiler rules).
  if the rider's token is the start of any definition, exit.
  repeat.

to scan a routine given a rider:
  if the compiler's abort flag is set, exit.
  add the routine to the routines given the rider's token's first.
  move the rider (compiler rules).
  scan the routine's routine header given the rider.
  if the rider's token is not the colon byte, abort with "This routine header is improperly formulated." and the routine's locus; exit.
  move the rider (compiler rules).
  scan the routine's routine body given the rider.

to scan a routine header given a rider:
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  put the rider's token's first into the routine header's first.
  put -1 into the routine header's last.
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is the colon byte, exit.
  if the rider's token is the period byte, exit.
  put the rider's token's last into the routine header's last.
  move the rider (compiler rules).
  repeat.

to scan a source file:
  if the source file is nil, exit.
  if the compiler's abort flag is set, exit.
  slap a rider on the source file's buffer.
  move the rider (compiler rules).
  loop.
  if the compiler's abort flag is set, exit.
  if the rider's token is blank, exit.
  if the rider's token is the start of any type, scan a type given the rider; repeat.
  if the rider's token is the start of any global, scan a global given the rider; repeat.
  if the rider's token is the start of any routine, scan a routine given the rider; repeat.
  abort with "I was hoping for a definition but all I found was '" then the rider's token then "'." and the rider.
  repeat.

to scan some source files:
  if the compiler's abort flag is set, exit.
  get a source file from the source files.
  if the source file is nil, exit.
  scan the source file.
  repeat.

to scan a type given a rider:
  if the compiler's abort flag is set, exit.
  add the type to the types given the rider's token's first.
  move the rider (compiler rules).
  scan the type's name given the rider.
  put the type's name into the type's plural name.
  pluralize the type's plural name.
  if the rider's token is "has" or "have", scan the type given the rider (has or have); exit.
  if the rider's token is not "is" or "are", abort with "I was expecting an 'is' or 'are', but I found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  if the rider's token is any numeric literal, scan the type given the rider (unit of measure); exit.
  if the rider's token is not any indefinite article, abort with "I was expecting an indefinte article, but I found '" then the rider's token then "'." and the rider; exit. 
  move the rider (compiler rules).
  scan the type's base name given the rider.
  scan any optional info for the type given the rider.
  if the rider's token is not the period byte, abort with "Types need to end with a period, I found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  index the type.

to scan a type given a rider (has or have):
  if the compiler's abort flag is set, exit.
  move the rider (compiler rules).
  put "record" into the type's base name.
  scan the type's fields given the rider.
  if the rider's token is not the period byte, abort with "Types need to end with a period, I found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  index the type.

to scan a type given a rider (unit of measure):
  if the compiler's abort flag is set, exit.
  convert the rider's token to the type's scale.
  if the type's scale is 0, abort with "Zero is an invalid scale." and the type's locus; exit.
  move the rider (compiler rules).
  scan the type's base name given the rider.
  if the rider's token is not the period byte, abort with "Types need to end with a period, I found '" then the rider's token then "'." and the rider; exit.
  move the rider (compiler rules).
  index the type.

the scanning timer is a timer.

a scratch is a local.

to scrub an index:
  get a bucket given the index.
  if the bucket is nil, exit.
  if the bucket's refers are empty, repeat.
  scrub the bucket's refers.
  repeat.

to scrub some refers:
  swap the refers with some other refers.
  loop.
  put the other refers' first into a refer.
  if the refer is nil, exit.
  remove the refer from the other refers.
  if the refer's pointer is nil, destroy the refer; repeat.
  append the refer to the refers.
  repeat.

to set the compiled flag in a variable:
  if the variable is nil, exit.
  if the variable's compiled flag is set, exit.
  set the variable's compiled flag.
  if the variable's kind is not "global", exit.
  if the variable's literal is nil, exit.
  find a routine given "put" and the variable's literal's type and "into" and the variable's type.
  if the routine is nil, find the routine given "convert" and the variable's literal's type and "to" and the variable's type; set a flag.
  if the routine is nil, abort with "The type of this global and the type of its literal are not compatible." and the variable's locus; exit.
  compile the body of the routine.
  if the flag is set, put "convert the " then the variable's literal's name then " to the " then the variable's name then ". " into the variable's initializer string.
  if the flag is not set, put "put the " then the variable's literal's name then " into the " then the variable's name then ". " into the variable's initializer string.

to skip to the next word in a substring:
  if the substring is blank, exit.
  if the substring's first's target is noise, break.
  add 1 to the substring's first.
  repeat.
  skip any leading noise in the substring.

a source file is a thing with a path and a buffer.

the source files are some source files.

a tag is a number.

a term has a variable and a phrase.

to transmogrify a fragment:
  if the compiler's abort flag is set, exit.
  if the fragment is nil, exit.
  if the fragment's tag is the push address tag, transmogrify the fragment (push address); exit.
  if the fragment's tag is the call internal tag, transmogrify the fragment (call internal); exit.
  if the fragment's tag is the load address tag, transmogrify the fragment (load address); exit.
  if the fragment's tag is the increment tag, transmogrify the fragment (increment); exit.
  if the fragment's tag is the dereference tag, transmogrify the fragment (dereference); exit.
  if the fragment's tag is the jump false tag, transmogrify the fragment (jump false); exit.
  if the fragment's tag is the not tag, transmogrify the fragment (not); exit.
  if the fragment's tag is the exit tag, transmogrify the fragment (exit); exit.
  if the fragment's tag is the repeat tag, transmogrify the fragment (repeat); exit.
  if the fragment's tag is the break tag, transmogrify the fragment (break); exit.
  if the fragment's tag is the prolog tag, transmogrify the fragment (prolog); exit.
  if the fragment's tag is the epilog tag, transmogrify the fragment (epilog); exit.
  if the fragment's tag is the push value tag, transmogrify the fragment (push value); exit.
  if the fragment's tag is the call external tag, transmogrify the fragment (call external); exit.
  if the fragment's tag is the load eax tag, transmogrify the fragment (load eax); exit.
  if the fragment's tag is the save eax tag, transmogrify the fragment (save eax); exit.
  if the fragment's tag is the call indirect tag, transmogrify the fragment (call indirect); exit.
  if the fragment's tag is the routine address tag, transmogrify the fragment (routine address); exit.

to transmogrify a fragment (break):
  put the repeat tag into a tag.
  find another fragment given the fragment and the tag.
  if the other fragment is nil, put the finalize tag into the tag. \ for break without a loop or after a loop
  find a third fragment given the current routine's fragments' last and the tag (backwards).
  if the third fragment is nil, abort with "Internal error - transmogrify a fragment (break)"; exit.
  if the third fragment's next is nil, abort with "Internal error 2 - transmogrify a fragment (break)"; exit.
  attach $E9 and the third fragment's next's address to the fragment. \ jmp the destination's address

to transmogrify a fragment (call external):
  attach $FF15 and the fragment's entry's address to the fragment's code. \ call [the fragment's entry's address]

to transmogrify a fragment (call indirect):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  attach $FF12 to the fragment's code. \ call [edx]

to transmogrify a fragment (call internal):
  get an address given the fragment's routine.
  attach $E8 and the address to the fragment. \ call the fragment's routine's address

to transmogrify a fragment (dereference):
  attach $8B95 and the fragment's variable's offset to the fragment's code. \ mov edx,[ebp+the fragment's variable's offset]
  attach $8B12 to the fragment's code. \ mov edx,[edx]
  attach $8995 and the fragment's variable's offset to the fragment's code. \ mov [ebp+the fragment's variable's offset],edx

to transmogrify a fragment (epilog):
  if the current routine's callback flag is set, attach $5F5E5B to the fragment's code. \ pop edi, esi, ebx
  attach $8BE5 to the fragment's code. \ mov esp,ebp
  attach $5D to the fragment's code. \ pop ebp
  attach $C2 and the current routine's parameter size to the fragment's code. \ ret the current routine's paramter size

to transmogrify a fragment (exit):
  find another fragment given the fragment and the finalize tag.
  if the other fragment is nil, abort with "Internal error - transmogrify a fragment (exit)"; exit.
  attach $E9 and the other fragment's address to the fragment. \ jmp the destination's address

to transmogrify a fragment (increment):
  if the fragment's variable is nil, abort with "Internal error - transmogrify a fragment (increment)"; exit.
  if the fragment's variable's kind is not "scratch", abort with "Internal error 2 - transmogrify a fragment (increment)"; exit.
  attach $8185 and the fragment's variable's offset and the fragment's number to the fragment's code. \ add [ebp+the fragment's variable's offset],the fragment's number

to transmogrify a fragment (jump false):
  find another fragment given the fragment and the end if tag.
  if the other fragment is nil, abort with "Internal error - transmogrify a fragment (jump false)"; exit.
  attach $83F800 to the fragment's code. \ cmp eax,0
  attach $0F84 and the other fragment's address to the fragment. \ je the destination's address

to transmogrify a fragment (load address):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  attach $8995 and the fragment's other variable's offset to the fragment's code. \ mov [ebp+the fragment's variable's offset],edx

to transmogrify a fragment (load eax):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  if the fragment's variable is nil, abort with "Internal error - transmogrify a fragment (load eax)"; exit.
  if the fragment's variable's type is nil, abort with "Internal error 2 - transmogrify a fragment (load eax)"; exit.
  if the fragment's variable's type's length is not 4, abort with "Internal error 3 - transmogrify a fragment (load eax)"; exit.
  attach $8B02 to the fragment's code. \ mov eax,[edx]

to transmogrify a fragment (not):
  attach $83F001 to the fragment's code. \ xor eax,1

to transmogrify a fragment (prolog):
  attach $55 to the fragment's code. \ push ebp
  attach $8BEC to the fragment's code. \ mov ebp,esp
  put the current routine's local size divided by 4 into a number.
  if the number is not 0, attach $B9 and the number and $6A004975FB to the fragment's code. \ mov ecx,number; loop: push 0; dex ecx; jnz loop
  if the current routine's callback flag is set, attach $535657 to the fragment's code. \ push ebx, esi, edi

to transmogrify a fragment (push address):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  attach $52 to the fragment's code. \ push edx

to transmogrify a fragment (push value):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  if the fragment's variable is nil, abort with "Internal error - transmogrify a fragment (push value)"; exit.
  if the fragment's variable's type is nil, abort with "Internal error 2 - transmogrify a fragment (push value)"; exit.
  put the fragment's variable's type's length into a length.
  if the length is 4, attach $FF32 to the fragment's code; exit. \ push [edx]
  if the length is 2, attach $66FF32 to the fragment's code; exit. \ push word ptr [edx]
  if the length is 1, attach $0FB61252 to the fragment's code; exit. \ movzxb edx,[edx]; push edx
  abort with "Internal error 3 - transmogrify a fragment (push value)".

to transmogrify a fragment (repeat):
  find another fragment given the fragment and the loop tag (backwards).
  if the other fragment is nil, abort with "Internal error - transmogrify a fragment (repeat)"; exit.
  attach $E9 and the other fragment's address to the fragment. \ jmp the destination's address

to transmogrify a fragment (routine address):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  if the fragment's routine is nil, abort with "Internal error - transmogrify a fragment (routine address)"; exit.
  get an address given the fragment's routine.
  attach $C702 and the address to the fragment's code. \ mov [edx],the address

to transmogrify a fragment (save eax):
  attach address loading code to the fragment's code given the fragment's variable. \ put address into edx
  if the fragment's variable is nil, abort with "Internal error - transmogrify a fragment (save eax)"; exit.
  if the fragment's variable's type is nil, abort with "Internal error 2 - transmogrify a fragment (save eax)"; exit.
  put the fragment's variable's type's length into a length.
  if the length is 4, attach $8902 to the fragment's code; exit. \ mov [edx],eax
  if the length is 2, attach $668902 to the fragment's code; exit. \ mov [edx],ax
  if the length is 1, attach $8802 to the fragment's code; exit. \ mov [edx],al
  abort with "Internal error 3 - transmogrify a fragment (save eax)".

to transmogrify some fragments:
  if the compiler's abort flag is set, exit.
  get a fragment from the fragments.
  if the fragment is nil, exit.
  transmogrify the fragment.
  repeat.

to transmogrify a routine:
  if the compiler's abort flag is set, exit.
  if the routine is nil, exit.
  if the routine's employs moniker is not blank, exit.
  if the routine's compiled flag is not set, exit.
  put the routine into the current routine.
  transmogrify the routine's fragments.

to transmogrify some routines:
  if the compiler's abort flag is set, exit.
  get a routine from the routines.
  if the routine is nil, break.
  transmogrify the routine.
  repeat.

the transmogrifying timer is a timer.

the type index is an index.

a type is a thing with
  a locus (reference),
  a name, a plural name,
  a partial moniker,
  a length,
  a base name, a base type (reference),
  a target name, a target type (reference) [pointers only],
  a scale ratio,
  some fields [records only],
  a cooking flag,
  a optional info resolved flag.

a type name is a name.

the types are some types.

the utility index is an index.

a variable is a thing with
  a locus (reference),
  a kind [literal, global, local, parameter, scratch],
  a compiled flag,
  a name, a nickname, a type name,
  a type (reference), \ actual type on literal, global, local; dereferenced type on parameters and scratches
  an address [globals and literals only] or 
  an offset at the address [locals, parameters, and fields only],
  a count [fields only],
  a reference flag [fields only],
  a redefinition target name [fields only],
  a by-value flag [parameters only],
  an global body [globals only],
  an initializer string [globals only],
  a literal (reference) [globals only - constant with which to initalize the global],
  a hex string called data [literals only].

the writing timer is a timer.