GNUMakefile: Save entire git id.

factor.cmd: Save entire gid id.

report: Add build number to mason reports.

io.files: fix docs

bootstrap.image.upload: Upload build images as well for posterity.

io.files: Add change-file-lines and change-file-contents words.

tools.image-analyzer.gc-info: Deferred words don't have any gc-info. Fix the unit test to account for this. Fixes #1394.

contexts.hpp: Increase callstack reserve space to 16k for Mac64. Fixes issue #1419.

opengl: Temporary (?) fix for the ui. Issue #1379.
Throwing gl errors is not helpful because the ui gets messed up anyway. Print the error and continue. Maybe we should add a section in the F3 error window for opengl errors instead of printing them in the global stdout.
- We could also use gl-error on every platform except for MacOSX 10.11
- We could fix the underlying gl drawing commands that cause this error.

urls: allow + in protocols, e.g. git+https://

vm: minor fixes.

VM: fix silly compile error

kernel.tests: address of fault is now in the 3rd element, so these tests
need to be updated

VM: bump stack_reserved from 1kb to 4kb

The added test case fails with a doulbe fault, which appears to be
caused by a stack overflow in the code that tries to handle the stack
overflow. So bumping it to 4096 bytes should give the code enough stack
space to play with.

VM: merge full_collector.hpp into full_collector.cpp

VM: new method context::address_to_error

VM: signal_error and fp_trap_error not needed, call general_error directly

VM: a bunch of methods on factor_vm that can be converted into free
functions

I think that makes it easier to see whats going on than having
everything added to factor_vm

VM: lets merge entry_points.hpp with vm.hpp, so you have one less header
file to worry about

VM: you can insert the write_barrier() the first time you interate the
blocks, so you don't need to do it twice

VM: new method visit_instruction_operands(), it replaces the instruction
operand iteration code in compaction.cpp and image.cpp

VM: refactors slot_visitor by removing a lot of one-use methods

I think it's easier to see the code flow if small method bodies that are
only called once are inlined into visit_all_roots() instead

VM: word_stack_frame_p() is not used and find_all_quotations() is
trivial so those methods can be removed

VM: using compute_external_address everywhere instead of store_external_address

VM: new method compute_external_address

VM: remove the collect_compact_code_impl(), collect_compact_impl() can
be used instead

this might slow down collect_growing_heap(), but heap growth happens so
rarely that it shouldn't matter

VM: init_code_heap is trivial and only used once, so let's remove it

VM: object_compaction_updater -> lambda func

VM: another opportunity to use a lambda function over a struct

VM: use a function update_relocation to replace the
code_block_compaction_relocation_visitor struct

json.reader: Fix json reader for empty files to parse as H{ }. Add path>json word.
Rename read-jsons

tools.deploy: increase image size for linux32

syntax docs: Fix octal example.

syntax: fix example in syntax-floats.

stack-checker: too tired to figure out which using is required but not used.

stack-checker: using cleanup.

math.parser: make float-parse:point a fixnum.

math.parser: some inline, some fixnum+fast, some disable tests.

math.parser: support >bin and >oct for floats

This is for symmetry with "0o1p0", "0b1p0", bin> and hex> which
all already work

math.parser: add tests/docs for floats 0b 0x bin> float> since they work

docs: hex floats exponents became mandatory

math.parser, don't take infinite time to parse huge exponents

math.parser: don't lose precision in make-float-bin-exponent

reddit: use unix-time>timestamp.

calendar.format: don't need unix-time>relative-time.

unix-time>timestamp relative-time

math.ratios: moving to core.

hacker-news: fix typo with descendants. use unix-time>relative-time

calendar.elapsed: Support relative times in the future with "3 hours hence" etc.
Add unix-time>relative-time word for convenience.

calendar.elapsed: make generic for more convenience.

reddit: use calendar.elapsed for relative-time.

hacker-news: add relative timestamp on posts.

reddit: stop using tuples and just use the JSON.

Nice-looking tuples are nice but reddit keeps adding fields to their objects
and breaking our from-slots.  We could hide the error, or ignore the extra
fields but this is probably better for now.

calendar.elapsed: adding some elapsed time words.

io.files.windows: Need the SLOT: file from io.sockets.secure.openssl

hacker-news: Fix using, fix bug printing HN company posts. Refactor a bit

hacker-news: use new hackernews api on firebase.

benchmark.fasta: rename random.

compiler.cfg.utilities: make it so block>cfg initializes spill-area-align

fix another doc using.

fix doc using.

fix some help-lint errors.

io.backend.unix.macosx: change to << require >>.

command-line: rename file to path for user-init-error which is kinda exactly like a source-file-error.

unix: don't need << >>.

math.floats.env: don't need << >>.

ui: cleanup some usings.

ui.images: don't need to << >>.

ui.commands: don't need to \ .

io.backend.unix.macosx: change USE: to require.

alien.libraries: don't need << >>.

disjoint-sets: some cleanup.

json.reader: fix segfault when parsing non-JSON documents.

json.reader: enforce json> takes a string.

compiler.cfg.*: tests against #1308

compiler.cfg.ssa.destruction.coalescing: refactor and maybe a fix for #1308

the eliminatable-copy? word is the fix. the previous code only checked
that the registers had the same register class, but you also need to
check that they dont have the same representation size. because a copy
from double-rep -> double-2-rep is not eliminatable

compiler.cfg.*: some extra unit tests for the compiler

compiler.cfg.ssa.destruction.coalescing: simpler code for setting up the
initial leader-map and class-element-map

cpu.x86: define %alien-invoke and %alien-indirect using %alien-assembly

Docs: various more compiler-related docs

compiler.cfg.representations.selection: use a union instead of a generic
to see if an insn is peephole-optimizable + test

compiler.tree.*: new docs

compiler.cfg.*: even more docs

compiler.tree.escape-analysis.*: new doc files

compiler.tree.escape-analysis.allocations: stub doc file from comments

compiler.cfg.*: a bunch of docs updates

compiler.cfg.representations.selection: some initial docs from comments

compiler.cfg.linear-scan.live-intervals: simpler code for finding the
sync points in the cfg

compiler.cfg.instructions: ##read -> read-insn and ##write -> write-insn

compiler.cfg.instructions: rename ##allocation to allocation-insn,
because it's nicer if all instruction unions have the -insn suffix and
the ## prefix is reserved for tuples

math.statistics: fix docs

core: rename parse-call( to parse-call-paren

math.statistics: clean up some weird stack effects

ui.gadgets.panes: don't use extract-keys, don't clone twice in specified-font.

ui.gadgets.sliders: rename slider-pen-tuple to slider-pen.

ui.gadgets.grids: rename grid-layout-tuple to grid-layout.

bootstrap: cleanup usings.

math.integers, comment and simplify bignum/f

change the "while" that could only execute once to "when"
change the f/loop word name to "mantissa-and-guard" since it's what it
computes
change the check against 2^53 to be explicit

math.integers, bignum/f, improve performance.

This changes avoids looping many times if the denominator is a power of
2. After this change, the implementation matches the linked sbcl
algorithm.  This was probably a mistake done when porting the algorithm.
Basically, as an optimization, all trailing zeros are removed from the
base2 representation of the denominator to have smaller bignums to
divide. But the previous factor implementation didn't take this into
account when making the initial guess of the shift of the numerator to
obtain a result in the range [2^54-1,2^53]. The loop would then correct
the initial guess by a factor of 2 at each iteration, so it would run as
many iteration as the denominator base2 power reduction, instead of only
a few times. For pathological cases, the speed up is huge (10^4):
1 1000 2^ bignum/f

math.integers, fix bignum/f for results in ]0x1.0p-1022,0x0.4p-1022]

math.vectors.conversion: [foo] for words that make quots is ok, but [[foo]] is overboard. change to ([foo])