Fixed bigfloat functions that assumed (fixnum? x) means x fits in a _long
(not true on Win64)
Hopefully fixed dangling pointer errors that broke `math/bigfloat' on Win64.
It apparently had no _long/_int mismatches, but GC on Win64 will run between
creating an `_mpz' and using its value after passing it as an output argument
to MPFR functions. That doesn't seem to happen on 64-bit Linux or Mac. No
idea why, but Win64 exposed the problem so... that's good, I guess.
Rewrote `rational->bigfloat' to not use GMP's rationals
More/better bigfloat tests
Added bigfloat stress test w/ weak leak detection
Reenabled custodian shutdown callback that clears MPFR constants, because it
seems to work now
Removed `mpfr-available?' because it would only return non-#f
Note: this isn't the ideal location for this in the long
run because it isn't a special form. When we have more
bindings like this, we should move them to a new manual
section.
Allowing them would require support for immutable fxvectors and
flvectors, interning, and more. Since the motivation for reader
support is to make marshaling and unmarshaling easier, allow
them only in `read' mode. Change printing to make then unquotable.
More generally, a `splicing-syntax-parameterize' wrapping immediate
compile-time code effectively parameterizes the compile-time code as
well as any macro-triggered compile-time code. This is implemented by
using a compile-time parameter that complements each syntax binding.
Use `raise-user-error' for `raco pkg ...' errors, so that stack
traces don't print out for external errors. Reformat error messages
generally to match current conventions. Use logging for debugging
output.
The default `raco pkg' mode should work right for a
multiple-version installation (because everything in
Racket should work in a multiple-version installation).
Along the same lines, `raco pkg' should work if the
installation directory is unwriteable. So, the default
mode is user-specific and version-specific.
Use `--shared' or `-s' for user-specific, all-version
installs.
By default, `raco pkg show' now shows packages installed
in all three modes (installation-wide, user- and version-
specific, and user-specific all-version). Use `-i', `-u',
or `-s' to show just one of them.
For now, "METADATA.rktd" is still recognized as a fallback.
Also, rewrite package source type and name inference,
make ".zip" the default format for `raco pkg create',
and many doc edits.
Now works with the handler argument omitted, in which case
the default handler is used. Note that the default handler
cannot be used in conjunction with the default prompt tag
because it is unsound to do so.
Reset result is from last step; looking at it was probably causing
spurious failures and busy-timeouts.
Transaction completion relies on statements being reset reliably.
original array strict instead of returning a new strict array.
(Finally!) The hard part is keeping the Array type covariant. The
solution is to keep the store in the closure of the array's
procedure instead of in the Array struct itself.
Also:
- remove the restriction on the use of unquote in define-judgment-form
- allows limited use (I modes only) of judgment-forms in terms
- allows the use of define-relation with the search/unification
based random term generation
Cleaned up other docs in preparation for alpha-testing announcement
Created `math/utils' module for stuff that doesn't go anywhere else (e.g.
FFT scaling convention, max-math-threads parameters)
Reduced the number of macros that expand to applications of `array-map'
Added `flvector-sum', defined `flsum' in terms of it
Reduced the number of pointwise `flvector', `flarray' and `fcarray' operations
Reworked `inline-build-flvector' and `inline-flvector-map' to be faster and
expand to less code in both typed and untyped Racket
Redefined conversions like `list->flvector' in terms of for loops (can do
it now that TR has working `for/flvector:', etc.)
Refactored many of the fold functions (e.g. `array-axis-andmap' is gone,
replaced by short-cutting `array-axis-and', which is sufficient because the
result of `array-map' is non-strict; added `array-count', `array-all-fold';
removed `array-all=' and friends)
Turned common folds into macros (preserves return types better, speeds up
compilation time)
Exposed a safe variant of `unsafe-array-axis-reduce'
For example, a new DrRacket window (with a file named tmp.rkt in the
and 356 afterwards. This is under mac os x with, I believe, the
default system font sizes. (The file is important because different
languages can have different buttons in the toolbar and the filename's
length itself can affect the minimum size.)
Mostly this change is the addition of a new kind of panel that
lets its children have multiple fixed sizes (as opposed to
just a single minimum size and (optionally arbitrarily large))
It also adjusts the various toolbar buttons to use this new code.
Also, there's a few tweaks to shrink other things that became the
limiting factor in shrinking the width of the DrRacket window.
Currently, at least for #lang racket programs, the toolbar buttons
along the top of the window are the limiting factor (including the
save button). With a bogus language (ie, #lang rackeeet), the bottom
bar is the limiting factor, since that will have only the Save, Run,
and Stop buttons.
related to PR 13281
Also switches scribble search trampoline to standard DOCTYPE.
Scribble's HTML output currently relies on the quirks-mode
box model for layout of the many tables used in rendering.
However, Scribble doesn't need the rest of the changes in
browser quirks modes, so we choose a DOCTYPE that just
changes the box model.
It's non-obvious how to replicated this formatting with CSS
in standard-mode rendering. Probably a better long term
solution is to move away from table-based layout.
See further discussion on GitHub pull request 158 here:
https://github.com/plt/racket/pull/158
An old package intended for use with `raco setup -A' can be
installed with `raco pkg install'.
A package created with `raco pkg create --format plt' can be
installed with `raco setup -A', although it could leave behind
weird "MANIFEST.rktd" and other files in the "collects" directory.
An old package created with `raco pkg create --format plt' still
can be used with `raco pkg install', although not with `raco setup -A'.
The change from previous 'raco pkg' behavior is that package content
now claims to be in a "collects" directory that is
installation-relative, and unpacking redirects "collects" to the
package-staging area. At the same time, unpacking still works the
same as before on ".plt" archives that are not installation-relative.
The main problem is that it asked exact? on an unknown
value and exact? works only on numbers.
But since I was here, also try to clarify the error message a bit.
When switching tabs while an on-reflow initiated callback
might still be running can lead to bogus information
coming back from position-locations, as the editor loses
its admin.
So, we just give up recomputing the rectangles when the
admin is gone and, for now, expect that there will be
another on-reflow call when the admin comes back that'll
restart the process (not sure that this is guaranteed tho)
* bernoulli -> bernoulli-number
* farey -> farey-sequence
* fibonacci/mod -> modular-fibonacci
* order -> unit-group-order
* orders -> unit-group-orders
Documented `make-fibonacci' and `make-modular-fibonacci'
Reworked text about loading external libraries in docs for `math/bigfloat'
Removed type aliases like Z, Q, Prime (I like them, but TR was printing them
in unexpected places like array return types)
clean up build
Moved `float-complex?' and `number->float-complex' to `math/base',
documented them
Documented `flexpt1p'
Removed `samples->immutable-hash' (not covariant anyway; not going to
use hashes)
Commit 8653bc6792 caused
the doc navigation to render oddly on Opera due to how
it handles . This commit retains the spacing
for text browsers, but fixes the navigation on Opera.
Fixed a few limit cases in some distributions (e.g. (uniform-dist 0 0) didn't
act like a delta distribution, (beta-dist 0 0) and (beta-dist +inf.0 +inf.0)
pretended to be defined by unique limits even though they can't be)
Made integer distributions' pdfs return +nan.0 when given non-integers
Added "private/statistics/counting.rkt", for hashing and binning samples
Added `flvector-sums' (cumulative sums with single rounding error)
Added `flinteger?', `flnan?' and `flrational?', which are faster than their
non-flonum counterparts (at least in Typed Racket; haven't tested untyped)
If a path to a directory is converted to an URL it loses
its trailing path separator.
This can lead to a bug if the URL is used as a base URL to
build other URLs (e.g. combine-url/relative).
There are minor benefits to using fxvectors instead of vectors:
the GC knows that an fxvector has no pointers inside, and the
bytecode compiler knows that `fxvector-ref' produces a fixnum.
BTW, a benefit of fxvectors over byte strings is the lack of an
indirection internally. (Unlike a byte string, the content of
an fxvector is "inlined" into the vector object.)
Change `bit-vector-count' to `bit-vector-length', add arguments
to `bit-vector-copy', use `racket/private/vector-wraps' (which
should be moved to a public place) to implement things like
`for/bit-vector'.
Profiler output suggests that forward-match is a bit expensive. Here
is profiler output from the original code, when profiler is wrapped
around tabify-selection:
------------------------------------------------------------------------------------------------------------
loop [34] 0.1%
get-backward-sexp method in ...k/private/racket.rkt:425:2 [28] 99.9%
[37] 50648(61.1%) 0(0.0%) stick-to-next-sexp? method in ...k/private/racket.rkt:425:2 ...
do-forward-match method in ...rk/private/color.rkt:71:2 [50] 99.9%
...
------------------------------------------------------------------------------------------------------------
get-forward-sexp method in ...k/private/racket.rkt:425:2 [38] 17.1%
stick-to-next-sexp? method in ...k/private/racket.rkt:425:2 [37] 82.9%
[50] 61043(73.6%) 53(0.1%) do-forward-match method in ...rk/private/color.rkt:71:2 ...
colorer-driver method in ...rk/private/color.rkt:71:2 [66] 99.8%
match-forward method in paren-tree% [72] 0.1%
------------------------------------------------------------------------------------------------------------
The patch does the prerequisite string matching before calling forward-match.
Reference to dev list: http://lists.racket-lang.org/dev/archive/2012-November/010976.html
A few invariants involving subtree-width and black-height balance
could break if singleton nodes were reused; bugs were due to stale
data in the nodes.
The token tree implements the implicit interface in the original
splay-based token tree module in syntax-color/token-tree. However, it
does not appear to perform significantly differently in the case of
indentation yet. It needs some additional profiling and analysis to
see if we can take advantage of the richer structure in the rb tree.
Synchronous mode implies fsync(), which makes updates *much*
slower on some machines, such as the DrDr machine. The doc
database doesn't need to survive a catastrophic failue
(such as a power failure or OS crash), so turn synchronous
mode off.
Handle close parentheses in a smarter way while in
auto-parens mode and be a little more smart about
inserting brace pairs in general.
In summary:
- Add some "smart-skip" behavior to insert-close-paren,
described in the documentation.
- When auto-parens mode is enabled,
the existing "balance-parens" keybinding invokes
insert-close-paren with a smart-skip argument of
'adjacent
- A new "balance-parens-forward" keybinding invokes
insert-close-paren with a smart-skip argument of
'forward (whether or not auto-parens mode is
enabled)
- Enable basic smart-skip behavior for
strings ("...") and |...| pairs, specifically, typing
a double-quote or bar character when the cursor
immediately precedes one causes the cursor to simply
skip over the existing one
- Tweak auto-insertion of block comment pairs; i.e.
typing hash and a bar results in a properly balanced
#||# pair. Also, when you type a bar character when
the cursor immediately precedes a closing bar and
hash of a comment, then the cursor skips over both
characters (this seems better than having it just
skip over the bar, and then having to introduce a
new keybinding to detect when a hash is typed while
the cursor is between a bar and a hash)
- In strings and line/block comments, auto-parens mode
no longer has any effect (you can still use the M+..
keybindings to force insertion of a particular brace
pair)
- Detect when a character constant is being typed, and
don't insert brace pairs if so; i.e. if the cursor
is immediately after #\ , then typing any open parens,
double quote, or bar, does _not_ result in the
insertion of an open/close pair even in auto-parens
mode
- Add a bunch of tests related to auto-parens, matching
pairs of braces, strings, comments, etc. to
collects/tests/framework/racket.rkt
Changes the implementation of highlight-range so that it
only recomputes all of the new locations from the positions
when on-reflow is called (otherwise only computing the
relevant ones) and make the on-reflow callback chop itself
up, in case there are lots of highlighted ranges to avoid
tying up the event loop.
Changes searching so that it doesn't neccessarily compute
the entire search results in a single event callback
(but also make it start the computation more aggressively)
Overall, this changes the strategy from one that, for any potentially
long-running callback, just tried to push it off into the future, into
a strategy that tries to avoid long-running callbacks by breaking the
work up into chunks, but starting the first chunk immediately (in a
low-priority callback).
Also, misc other changes to make this work better and generally clean
things up.
Specifically, when a style change happens that ends up
not changing the size of anything, then track that
lack of size change enough to be able to avoid
calling on-reflow.
This is important for the interaction between the
colorer and the search bubbles in DrRacket. That is,
when you make an edit that causes the colorer to have
lots of work, then each chunk of work it does before
yielding control to the event loop would also trigger
a call to on-reflow, which would cause the search bubbles
to recompute their sizes. Overall, the main bad thing
this does is cause lots of allocation and aside from
that it doesn't hurt interactivity. Still, there is a
lot of useless work here, and those extra GCs can be
pretty substantial when you're doing something crazy like
searching for " " in a big file.... (there are 95k spaces
in unit.rkt, in case you were curious)
Change `raco setup' to guard database writes in different places
by an explicit lock that is implemented by place channels. Change
corss-reference reading to fall back to just loading ".sxref"
files if the database seems to be too contended at that point.
These changes are aimed at avoiding distaerous performance when
SQLite seems not to behave well.
Also, fix break and other exception handling near the "fast abort"
path for both reads and writes.
Replaced pointwise operators with macros that expand to applications of `array-map'; allows more precise return types and reduces compilation time
Changed literal array syntax to use #() to delimit rows instead of [] (still suggest using square parens, though)
Minor refactoring
Fixed a macro so that the only problem with "array-tests.rkt" now is that typed/rackunit is b0rked
This change makes document building --- and specially incremental
document building --- more scalable. The global duplicate-definition
check is handled by a database query, for example.
For example, the cross-reference information for the
Reference is now broken into about 16 pieces, so that
resolving a cross-reference into the Reference doesn't
require loading all cross-reference information for
the Reference.
Every document is split into two pieces, so that the title
of a document is roughly in its own piece. That way,
re-building the page of all installed documentation can be more
scalable (after some further changes).
Typically, the bluebox table includes keys that have interned parts,
so serialization can save space both on disk and in memory when the
bluebox information is reloaded.
Loading `db/sqlite3' no longer raises an exception if
the SQLite library isn't found. Instead, `sqlite3-connect'
raises an exception, while `sqlite3-available?' reports
whether it will work.
The dynamic test allows the documentation-help system
to continue to work if SQLite3 is not available. Currently,
though, `raco setup' still insists on using SQLite3 to
build the database of documented tags.
The `xref' produced by `setup/xref' uses the database to delay
loading "out.sxref"s, which cuts 64-bit DrRacket's initial
footprint by around 50MB (i.e., about 20%).
popup menu
Extends append-editor-operation-menu-items so that when you
pass an editor and a position, it checks to see if that spot
has a non-string% snip and, if so, copies that one position
(or cuts it, depending).
Then, use that extension in DrRacket
closes PR 12791
when the blue box doesn't fit in the visible region
in one direction (either x or y) but does fit
in the other region, then it was being drawn in
the wrong place
This code is still sub-optimal, since it isn't leaving
space for the words underneath the lock in the case
the lock is near the bottom of the visible region, but
it seems better to just let that be invisible rather
than make the lock float a bit in that case.
closes PR 13142
Fixes a memory leak in SSL_get_peer_certificate.
Fixes a memory leak (finalizer closure refers to obj) in create-ssl
for _SSL* obj. Correcting the finalizer to run caused mem corruption
(possibly due to double-freeing in mzssl-release, despite cancel box)
but changing to allocator/deallocator seems to avoid the problem.
- add enqueue-front!
- add queue-filter!
- use the predicates instead of the /c contracts
- make queue-length take constant time
- add some random tests
- note the running times of all of the operations in the docs
- make queues be sequences directly (and use make-do-sequence
to implement in-queue instead of building a list)
- added non-empty-queue? (note extra hypen as compared
to the past; this seems better since the function
wasn't exported before and we already have other
functions named "non-empty-<something>" but not
others namedn "nonempty-<something>")
check.rkt:
Added the actual check-match macro.
test.rkt:
Just a provide statement
check-test.rkt:
7 additional tests for check-match, and a macro to help create tests
check.scrbl:
Documentation and examples for check-match
It was pulling from `scheme/gui/base', instead. The one from `scheme/gui/base'
is now different and still pulls from `scheme/gui/base'.
This could break some programs that accidentally depended on `scheme/gui/base'
exports from `gui-dynamic-require', but it's more likely to fix problems.
The `scheme/base' module had become unreachable from the `mred' module.
While that normally would be a good thing, it lead to troublesome
multiple instantiations of `scheme/base' that caused problems for
attaching further modules to the namespace.
A page-setup dialog is now available on all platforms, which means
that no dialog will appear when a `pirinter-dc%' is created. Meanwhile,
note that `end-doc' normally shows a (different) dialog.
This is another old bug that could have caused validation failures
with flonums, but it showed up with fixnum tracking because fixnums
are more common (e.g., from `string-length').
There were really two bugs: information installed at the
wrong offet in one place, and a failure to detect that information
should be propagated in a different place. Fixing both avoids
a validation problem with `html/sgml-reader'.
Fixes after merge weirdness from pull request (specifically, removed `bfrandom' from "mpfr.rkt" again)
Removed dependence of math/flonum on math/bigfloat (better build parallelization)
Changed `divides?' to return #f when its first argument is 0
Made return type of `quadratic-character' more precise
Made argument types more permissive:
* second argument to `solve-chinese'
* second argument to `next-primes'
* second argument to `prev-primes'
are shown in the corner of the window
This was an attempt to avoid opening up a whole status line in the
bottom of the window much of the time. But it doesn't really work
since as soon as you have a syntax error (which are relatively common)
you get that whole line opened up. That it, this attempted GUI interaction
depended on the bogus premise that read errors are somehow happening
in a transient way between error-free states.
closes PR 13267
getter/setters instead of overriding a method
this has the benefit that the delegate does not have to be
rebuilt when switching tabs in drracket; we just leave the
old delegate on the old definitions text, and the swap it
back into the editor-canvas when we swap the text% object
itself back in.
coloring in the contour window to make only a single call to
invalidate-bitmap-cache
It was making two before, which could have pretty similar regions,
leading to two repaints instead of just one. When pushing the down
arrow near the bottom of the visible regions of the definitions text
was causing those two calls to take about 30 milliseconds and after
this change the one call seems to be about half that (but there is
lots of variance so I'm only sure that it helped some, not how much)
A long time ago, I tried to improve the interactiveness
of DrRacket when the contour window was open with the
code that is removed in this commit. Looking at it today,
it seems clear that this code was buggy (and, now that
we've had lots of experience with it, it didn't actually
help with interactivity either)
The problem is that the code didn't record enough
information about the change to the editor in the thunk put
into the 'todo' field. It would remember that a particular
range was out of date, but it woudln't remember which
characters were in that range, so when it would go to copy
the characters, it may be getting the wrong characters
(since another edit may have happened since the thunk was
stored in the todo field)
This change also has the side benefit that the time it takes
to change the contour window is now being tracked by the
colorer, which means that it'll give up a bit sooner
coloring less in each go, but hopefully maintaining the
interactivity
in the original GitHub fork:
https://github.com/ntoronto/racket
Some things about this are known to be broken (most egregious is that the
array tests DO NOT RUN because of a problem in typed/rackunit), about half
has no coverage in the tests, and half has no documentation. Fixes and
docs are coming. This is committed now to allow others to find errors and
inconsistency in the things that appear to be working, and to give the
author a (rather incomplete) sense of closure.
inside the same collection so this file can (when other
things aren't too different) be used in a version of racket
that doesn't generally have the tests
Track fixnum results in the same way as flonum results to enable
unboxing, if that turns out to be useful. The intent of the change,
though, is to support other types in the future, such as "extnums".
The output `raco decompile' no longer includes `#%in', `#%flonum',
etc., annotations, which are mostly obvious and difficult to
keep in sync with the implementation. A local-binding name now
reflects a known type, however.
The change includes a bug repair for he bytecode compiler that
is independent of the generalization (i.e., the new test case
triggered the old problem using flonums).
The `lazy-require' form expands to `define-runtime-module-path-index',
whch doesn't work right at phase levels other than 0. Work around the
problem by generating a submodule to hold the
`define-runtime-module-path-index' form.
This repair fixes `raco exe' on certain uses of `match', which in turn
uses `lazy-require' at compile time.
Also, use `register-external-module' to generate appropriate
dependencies on lazily loaded modules.
The new function allows declaration of a module dependency, as
opposed to a mere file dependency. Misuse of this function opens
the door to cyclic compilation dependencies, so we have to check
for that in `compiler/cm'.
Also, log a warning when it is used in a position where it
doesn't work rght with the executable creator. I didn't make
this case an error, because `define-runtime-path' can still
work in that case as long as no standalone executable needs
to be created.
The JIT was pessimistically using 64-bit jumps for long branches
or any jump between code that is allocated at different times.
Normally, though, code allocation stays within the same 32-bit
range of the heap, so stick to 32-bit jumps until forced by
allocation addresses to use 64-bit jump targets.
is no bluebox information, then we can just bypass updating
it on insertions (especially important when loading a big
file into drracket, as there is a lot of insertion but no
blue boxes (yet))
Specifically, two things:
- make drracket more careful to not crash when aspell
doesn't behave, and
- have a more careful test when clicking the menu item
(it now does a trial run of aspell instead of just
looking for the binary)
closes PR 13242 (I realize there is still a feature
request mentioned in the audit trail of that PR, but
since the main problem is fixed, I'll consider that
to just be something separate)
Commit ffe45ecce had introduced a regression with some
polymorphic functions imported between typed modules due to
miscommunicated variance information.
correct-xexpr?. Inverted the logic and replaced the
continuation-passing style with simpler test-for-error logic. Also
corrected typo in attribute symbol checker that could otherwise lead
to a contract error. (taking the cadr of a non-cadrable value)
I started from tabs that are not on the beginning of lines, and in
several places I did further cleanings.
If you're worried about knowing who wrote some code, for example, if you
get to this commit in "git blame", then note that you can use the "-w"
flag in many git commands to ignore whitespaces. For example, to see
per-line authors, use "git blame -w <file>". Another example: to see
the (*much* smaller) non-whitespace changes in this (or any other)
commit, use "git log -p -w -1 <sha1>".
In `(if (pair? x) E1 E2)', convert `(car x)' in E1 to
`(unsafe-car x)', and similarly for `(cdr x)'. Also,
`(begin (car x) (cdr x))' converts to `(begin (car x)
(unsafe-cdr x))' since `(car x)' implies a `pair?' test
on `x'.
- make clicking on the example languages
select the 'The Racket Language' radio button
- when the clicked example language matches
the buffer, have a more friendly message
This is used by the `function-with-arity' macro, and the use of `except'
looks like something that is better done with a keyword. I think that
this change should be fine since it's a private function.
All of these look safe. Also, see comment in `2htdp/batch-io' about the
splitting thing (which should probably be revised with the extensions to
`racket/string').
(I think that the change to `teachpack/htdp/dir' is fine too, looks like
the previous code is dealing with the old restriction of not requiring a
binding that conflicts with the language bindings.)
running the 'redraw the definitions/interactions label' timer when the
language didn't ask for those labels; this commit also avoids running
the timer when the user has disabled the labels
typing them in, in the module language test suite
this speeds it up; going from 140 to 105 seconds on my (mac)
machine. (drdr was taking 240 or so seconds, tho)
Although this shouldn't affect document rendering, since
each document is run under a custodian that is shut down,
it simplifies using the document individually to check for
leaks.
from, each time it starts on a new event boundary (this means that in
the old (5.3) version of the colorer, it also created a new co-routine
on each event boundary! (in other words, most of the reason one would
want co-routines here was bogus))
So, refactor the code to just always do this and eliminate a bunch of
set!'s and private fields in favor of just passing arguments like sane
code does. (We can't eliminate all of that, because we still do need
to be able to abort and thus all calls must be tail calls.)
cannot change its revision number during reading
This restriction was enforced only for editors that have non
string-snip% snips. The restriction was in place because the
implementation strategy was to chain thru the snips in the editor
using (send snip next) and that isn't safe if the revision number
changes.
The lifting of the restriction is implemented by tracking the position
in the editor where the last snip ended and, if the revision number
changes, starting over trying to get a snip from that position. This
has the effect that, if the revision number never changes, the code
should behave the same as it was doing before (so hopefully any new
bugs I've introduced in this commit will only show up if the old
implementation would have raised an error)
Also, exploit the lifting of this restriction in the colorer so it
doesn't to restart the port during to coloring that happens along with
the parsing
Apologies for the gratuitious reindent, but I was having
a lot of trouble reading this file; it appears to have
last been worked on in an Emacs that used tabs for indentation
and doesn't use the same tab width as drracket.
Add "Version" in front of a version name via `.version:before' or
`.versionNoNav:before' and `\SVersionBefore', so that they can
be configured through overriding CSS or Latex macro declarations.
Also, improve the documentation for how the `#:version' argument
of `title' is propagated to a `part' style property.
Closes PR 13227
As it turns out, changing the color (via change-style) can somtimes
split snips, which can change the revision number, which means that
the open port into the editor is no longer valid.
Since this doesn't seem to happen very much when editing in DrRacket,
we just detect this situation and give up on this colorer's port, and
hopefully it actually doesn't happen much (the place it happened that
let me notice this was when inserting an image via a menu in the
drracket test suites)
refactor it so it doesn't add anything to the continuation ever, and
just check if it has been a while since we started (giving other
events a chance to run, if so). Also, interleave the calls to
change-style with the parsing of the buffer to get a more accurate
count of the time the colorer is taking
Shape information allows the linker to check the importing
module's compile-time expectation against the run-time
value of its imports. The JIT, in turn, can rely on that
checking to better inline structure-type predicates, etc.,
and to more directy call JIT-generated code across
module boundaries.
In addition to checking the "shape" of an import, the import's
JITted vs. non-JITted state must be consistent. To prevent shifts
in JIT state, the `eval-jit-enabled' parameter is now restricted
in its effect to top-level bindings.
Updated example for for/digits to avoid confusion: it's not clear
otherwise that the intentional syntax error wasn't just a casual
mistake.
Added an example for sequence-add-between.
so that it waits until online check syntax actually
finishes (otherwise, there actually is a leak;
the link is broken when the message comes back from the
other place)
