Had been specifying Scheme lexer for code blocks, while waiting for
new Racket lexer to wend its way from Pygments to Pygments.rb to
Linguist to GitHub.
That day is almost here: Linguist will soon update and deploy to
GitHub. And Racket 5.3.2 is about to release. As a result, I think
this is the correct time to switch to the Racket lexer: It should be
live on GitHub by the time people are using Racket 5.3.2.
/cc @rmculpepper -- I think this commit should go into the 5.3.2
release.
- parsing of polydots values was fixed
- certain polydots error cases are now reported
- the custom application rule for values was fixed
Closes PR 13365
Please merge to 5.3.2
The prior code constructed the location of nonterminal maches out of
the the state of the stream after parsing. This isn't right for a few
reasons:
1. It doesn't get starting location correctly.
2. It doesn't behave when the non-terminal production did not
actually consume tokens for its parse.
This patch modifies the parsers to also pass along a
"last-consumed-token"; it, along with a few other changes, provides
the parsers enough information to accurately construct the locations,
even when no tokens have been consumed during the parse. We
synthesize a sentinel last-consumed-token token to take location from
the head of the stream.
The `+m' flag is a long-overdue shorthand for `++xref-in setup/xref
load-collections-xref', which links to installed documentation in
the same way as DrRacket's "Scribble HTML" button.
That is, use `+m' to link to installed documentation,
scribble +m mine.scrbl
instead of the previously recommended
scribble ++xref-in setup/xref load-collections-xref mine.scrbl
Merge to 5.3.2
I belive this should only be noticeable at the human timescale level
when the tabs have been switched to already and, in that case, seems
to go from 3-400 msec to 50-60 msec on my machine
Essentially all of that time is in redrawing the buffer, so that 50-60
msec is proportional to the height of the DrRacket window, roughly.
(The commit just makes drracket do a single redraw instead of about 4
or so of them per switch ...)
With either
configure --enable-pkgscope=installation
or
raco pkg config -i --set default-scope installation
the default scope of `raco pkg' actions can be changed from
user-specific to installation-wide.
We considered trying to guess when someone building Racket would prefer
installation-wide package scope by default. In particular, someone
building from source for in-place use seems likely to want
installation-wide scope by default. Then again, we don't want to
discourage in-place builds for Unix installations that are intended
for multiple users. So, no guessing for now.
Also, add a `--scope' argument to `raco pkg' commands, which is more in
line with other options, but keep `-i', etc., as shorthands.
The intent is that the configuration module can be rewritten without
recompiling code that uses it, so don't let the compiler inline
configuration values.
The problems were with
* `sqrt' and `expt' on single-flonum complex numbers
* `asin' and `acos' on single-flonum arguments and complex results
* `atan' on mixtures of single-flonum and exact arguments
* `gcd' on mixtures of single-flonum and flonum arguments
guard more of the filesystem manipulations with
handlers and log errors instead of letting them
be raised and show up as internal errors
related to PR 13403
teachpack menu.
Instead DrRacket explicitly changes the menu items when
the language changes or when a teachpack is added/removed
Also, Rackety.
Closes PR 13395
* At least stubbed out all (or almost all) `math/matrix' exports; many
have complete documentation (e.g. types, predicates, accessors,
constructors, for loops, conversion, much of "Comparing Matrices")
* Moved `matrix-zero?' and fixed to use (matrix-error-norm) as its norm
* Added `matrix-basis-cos-angle' (currently a stub; should return smallest
singular value of a certain matrix multiplication)
There appears to be no way to make `on-demand' work right for the
Unity window manager's global menu bar, since there's no notificiation
when the menu bar is clicked. We approximate the correct behavior
by calling `on-demand' when a containing frame loses the keyboard
focus, which might be because the menu bar was clicked; that may be
too late (because the menu has already been shown), but it should
work most of the time.
Closes PR 13347.
Relevant to PR 13395, but DrRacket will have to change to work
around the remaining limitations of `on-demand'.
This will make switching back and forth between 5.1.3 and the latest
not lose the frame size and position preferences (since the format
of the data is different now that the current release remembers
the position on a per-monitor-configuration basis)
* Gram-Schmidt using vector type
* QR decomposition
* Operator 1-norm and maximum norm; stub for 2-norm and angle between
subspaces (`matrix-basis-angle')
* `matrix-absolute-error' and `matrix-relative-error'; also predicates
based on them, such as `matrix-identity?'
* Lots of shuffling code about
* Types that can have contracts, and an exhaustive test to make sure
every value exported by `math/matrix' has a contract when used in
untyped code
* Some more tests (still needs some)
The synchronization result of a log receiver is now a vector of four
values, instead of three, where the last one reports the name.
Also, an optional argument to `make-logger' provides a notification
callback for each event sent to the logger.
These changes enable more control over loggers and events. Suppose
that you have processes A and B, and you want all log events of A
to be visible to B, but not vice-versa. Furthermore, you want the
log events to appear at B in the right order: if A logs an event
before B, then A's event should arrive at a log receiver's before
B's. Now that a log receiver gets the name associated with the
original event, and now that the name can be re-sent in a
`log-receiver', it's possible to give A and B separate loggers and
send all of the events from A's logger to B's logger. Furthermore,
you can use the notification callback so that when an event is logged
in B, you can make sure that all available events from from A's
logger have been transferred to B's logger.
One drawback to the current situation (after this commit) is that all
log messages are sent into the user's logger, even messages that come
about as part of DrRacket's implementation. It isn't clear how to fix
this without enumerating all of the possible messages to share and
explicitly forwarding them (both of which are suboptimal things).
On the plus side, the GUI now uses the "debug@GC" notation in a text
field, and when the logger pane is not open, there is no extra work
going on. Plus other, minor GUI improvements.
This was there, I believe, to avoid latency when clicking
on the [docs] links in the language dialog. But now that
we're using a database anyways, loading the xrefs is fast.
- use the same font/size as the definitions/interactions window
- add a checkbox to control scrolling behavior and,
- when scrolling, scroll to the begining of the line, not the end
Put the details consistently with event datatypes, instead
of trying to put them all in `sync', which better reflects
the extensibility of the set of synchronizable events.
it only looks left and right at hyphens and only
up and down at pipes, etc. This better handles the
case where you have something like this:
+--------------+
| (<= a-x b-y) |
+--------------+
Before this commit, it would have adjusted the hypens
inside the identifiers
adjust the way it changes characters so it
doesn't change them when they are already the right
thing (this means set-modified is not always called
and also improves performance in the case that little
changes in a big diagram)
Before this commit, things like this:
(define c% (class object% (super-new)))
(object-name c%)
would produce
'class:c%
but now classes and interfaces will be more like procedures and, in
the example above, just produce:
'c%
The underlying goal is to make error messages generated from contracts
like
(is-a?/c frame%)
have "(is-a?/c frame%)" in the message, instead of "(is-a?/c
class:frame%)"
This reverts commit c2468f1f9a.
The libjpeg documentation claims that it has no static state,
so atomic mode shouldn't be necessary. Also, the stress test is
still failing on some platforms, so there must be a different
problem than I thought.
Revert "do a little bit better job compressing the bytes"
This reverts commit 099a35881e.
Revert "adjust file to use the literal bytes for the ufo image"
This reverts commit fdd9344b27.
* Consolidated Gauss and Gauss-Jordan elimination
* Fixed Gaussian elimination to return all indexes for pivotless columns,
not just those < m
* Consolidated `matrix-row-echelon' and `matrix-reduced-row-echelon'
* Specialized row reduction for determinants; removed option to not do
partial pivoting (it's never necessary otherwise)
* Added `matrix-invertible?'
* Removed `matrix-solve-many'; now `matrix-solve' solves for multiple
columns
* Gave `matrix-inverse' and `matrix-solve' optional failure thunk arguments
* Made some functions that return multiple columns return arrays instead
(i.e. `matrix-column-space')
* Added more tests
The version number is included as the query part of the constructed
URL, so it is easily ignored by a server. The intent is that the
PLT PNRs will eventually support version-specific results.
* Split "matrix-constructors.rkt" into three parts:
* "matrix-constructors.rkt"
* "matrix-conversion.rkt"
* "matrix-syntax.rkt"
* Made `matrix-map' automatically inline (it's dirt simple)
* Renamed a few things, changed some type signatures
* Fixed error in `matrix-dot' caught by testing (it was broadcasting)
* Rewrote matrix comprehensions in terms of array comprehensions
* Removed `in-column' and `in-row' (can use `in-array', `matrix-col' and
`matrix-row')
* Tons of new rackunit tests: only "matrix-2d.rkt" and
"matrix-operations.rkt" are left (though the latter is large)
* Finally added `array-axis-expand' as a dual for `array-axis-reduce'
in order to implement `vandermonde-matrix' elegantly
* Better, shorter matrix multiply; reworked all matrix arithmetic
* Split "matrix-operations.rkt" into at least 5 parts:
* "matrix-operations.rkt"
* "matrix-basic.rkt"
* "matrix-comprehension.rkt"
* "matrix-sequences.rkt"
* "matrix-column.rkt"
Added "matrix-constructors.rkt"
Added `matrix', `row-matrix', and `col-matrix' macros
A lot of other little changes
Currently, `in-row' and `in-column' are broken. I intend to implement
them in a way that makes them work in untyped and Typed Racket.
JPEG reading and writing involve callbacks that need to be
atomic, since the stack-swapping games that a Racket thread
switch plays may not be ok with the JPEG library (as exposed
by the stress test). So, the JPEG reading and writing code
must read/write a string port, instead of directly from/to
the source/destination port, since a string port can be
used in atomic mode.
More precisely, do this for nested flows with the "refcontent" style.
For instance this Scribble:
@margin-note{Note: This is a note. Let's make it long enough that the
markdown output will have to line-wrap, to make sure the > mark starts
each line properly.}
Will render as this Markdown:
> Note: This is a note. Let's make it long enough that the markdown output
> will have to line-wrap, to make sure the > mark starts each line
> properly.
A site like GitHub.com will render this in a block-quote style
suitable for notes:
> Note: This is a note. Let's make it long enough that the markdown output
> will have to line-wrap, to make sure the > mark starts each line
> properly.
A phantom byte string is a small object that the memory
manager treats as an arbitrary-sized object, where the
size is specified when the phantom byte string is created
or or when size is changed via `set-phantom-bytes!'.
Things should now generally be set up to work better --
for example online check syntax is smarter now about
what happens when switching tabs/frames and this also
makes it easier to add new ways for a window to become
dirty (that is, for it to be known that it needs to
be recompiled)
Keep track of whether any Racket-managed subprocesses are pending,
and use waitpid(0, ...) only if there is one, to better cooperate
with an embedding environment.
Also, add a chapter to the "Inside" manual to explain the issues.
* `list->array' now accepts an optional shape argument, and always returns
an immutable array
* `vector->array' now accepts an optional shape argument, and always
returns a mutable array
* Removed `make-mutable-array' because `vector->array' does its job now (I
never liked the name anyway)
* Renamed `unsafe-mutable-array' to `unsafe-vector->array'
* Added optional type annotation to `array' macro to match `mutable-array'
* Reworded error messages in array broadcasting functions
* Made minor array doc fixes
Also allow `#:break' and `#:final' in all the `for:' macros.
Unfortunately, the expansion of `#:break' and `#:final' cannot be
typechecked at the moment.
renamed `partition-count' to `partitions' to be consistent with
`permutations', and gave better examples in `multinomial' docs
* (flulp-error +inf.0 +nan.0) was returning +nan.0 instead of +inf.0
* Type of `multinomial' didn't match its docs or `flmultinomial'
* Reworded docs for `diagonal-array'
* Reworked/reordered quite a few things in docs for `math/bigfloat'
* Fixed first identity given in `gamma-inc' docs
* Fixed descrption for `+max.0', etc.
Changing `current-url-encode-mode' from 'recommended to 'unreserved
causes `url->string' to encode !, *, ', (, and ) using %, which
can avoid confusing some parsers.
See also https://github.com/plt/racket/pull/198
Presumably, values shouldn't ever wrap and the bytestring is already
assured to be long enough, so using safe operations isn't strictly
necessary. This dangerous improvement yields speedup factor of ~1.86.
In set-argb-pixels, the critical loop for each pixel tests the value
of a boolean that was defined at the top level of the class. Forcing
these to be local variables gives a speedup of 1.5.
As long as some thread is ready to run, and in case the threads
synchronize after very little work, keep checking threads for
at least one thread quantum.
I also made some minor changes to `plot' so that its functions would
type more easily. In particular, everything that used to take a list
of vectors now accepts a (Sequenceof (Sequenceof Real)). The 3D
discrete histogram renderers now also accept lists as well as vectors
in the sequence of categories.
For now, in typed/plot functions, optional non-keyword arguments are
required. As soon as Vincent closes PR 13354, I should be able to
uncomment part of a macro in "typed/plot/syntax.rkt" to make them
correctly optional.
When a tag is serializable but not `write'--`read' invariant,
then it needs to be serialized and deserialized.
Also, clarify and check in `tag?' that a tag should be
serializable.
The revised protocol for a progress procedure doesn't create
the thread automatically, and it provides an event to indicate
when the progress count changes.
Render Scribble like
@hyperlink["url" "content"]
as Markdown like
[content](url)
Note that this only works for `@hyperlink`. The motivation is to
preserve content the author has explicitly written. (Previously,
`markdown-render.rkt` was discarding this; `text-render.rkt` still
does so.)
This does _not_ attempt to handle everything that `html-render.rkt`
would automatically generate and render as `<a>`. It simply can't --
things like hotlinked Racket keywords in code blocks simply won't work
in Markdown.
* Fixed and added tests for `quantile' and `median', documented them
* Added `sort-samples', documented it
* Removed `real-quantile' and `real-median' (too many design choices
right now; will revisit when implementing Kernel Density Estimators)
* Documented `absdev' and `absdev/median'
* Fixed `update-statistics*': now uses O(1) space as advertised (if the
sequences of values and weights both use O(1) space)
* Changed types of binning functions: allows using #:key in the future
(when TR supports function type cases that differ only by keyword
argument types better), places optional weights at the end like other
statistics functions
* Clarified binning docs about sort stability and half-open intervals
URL map were handled.
Previously, only ".." at the beginning of the URL were checked; now it
looks at the entire URL for a path that ultimately leaves the base.
Uses "Github flavored markdown". Specifically, code blocks are opened
using ```scheme so that Github will lex and format them as Scheme code
rather than generic monospace.
Note: I would have used ```racket, but we are still waiting for the
pygments.rb project to pull again from pygments-main -- to which I
contributed a Racket lexer back in August. After pygments.rb pulls,
can update this to use ```racket instead.
This should have been like this all along; I think it can lead to
race-conditions with high-priority events. In particular, something
might be pending in the event queue and then the test suite might
queue a high-priority event to check for it, which could happen before
the event that actually does the work that's being checked for!
When libmpfr wasn't available, the function created by `make-not-available'
would try to print any _mpfr arguments, which would call the custom _mpfr
printer, which would try to use a libmpfr function, which would call the
function created by `make-not-available', which would try to print...
The px unit is a pdflatex specific adjustable unit that is 1 bp (big
point = 1/72in) by default. This commit changes the latex renderer to
use bp which is a standard TeX unit equivalent to the default px
value. This change allows .tex files generated by scribble to work
with other latex engines such as xelatex.
http://nwalsh.com/tex/texhelp/Plain.html#dimensionshttp://tex.stackexchange.com/questions/41370/what-are-the-possible-dimensions-sizes-units-latex-understands
Here is a small test of using scribble and xelatex:
$ cat try.scrbl
@(require scriblib/figure redex/reduction-semantics redex/pict)
@(define-language L)
@(render-term L (term 1))
$ scribble --latex try.scrbl ; xelatex try
Cleaned up expected value code a little
Refactored running statistics objects (hid private fields, added
`update-statistics*')
Documented expected value functions and running statistics
Removed `bfpsi0' from bigfloat tests (DrDr's libmpfr doesn't have it)
Commented out custodian shutdown callback that frees MPFR's cache
(something's broken)
of libmpfr (like DrDr's) that don't have it
Reimplemented really simple FFI functions (e.g. mpfr-prec, mpfr-exp) to
avoid calling overhead
Renamed `bigfloat-sign' to `bigfloat-signbit'
Renamed `bigfloat-sig+exp' to `bigfloat->sig+exp' (for symmetry with
`sig+exp->bigfloat')
use longs for the "limbs" of bigints. However, when GMP's configure script
detects that mingw64 is compiling, it defines LONG_LONG_LIMB, which makes the
type of limbs long long, or 64 bits. This is fine; a 64-bit machine should use
64-bit ints for the digits of its bigints. It would have been nice to know
this special case earlier, though I can see why it's not advertised: most
users don't need to know, and it seems like it's obviously the right choice to
make when dealing with Win64's annoying ABI.
Made "mpfr.rkt" search for 'mpfr_set_z_exp if 'mpfr_set_z_2exp isn't found.
Hopefully this allows the bigfloat tests to finish on DrDr. If not, DrDr
will need a libmpfr upgrade.
Made some minor doc fixups
Exact 0 turns out to also be a corner case for addition.
At this point, mixed-mode optimizations pretty much only apply for mixes
of floats and literal non-zero non-floats.
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)
This tracking allows the compiler to treat structure sub-type
declarations as generating constant results, and it also allows
the compiler to recognize an applications of a constructor or
predicate as functional.
The JIT takes advantage of known-constant bindings to avoid the
check that a variable is still bound to a structure predicate,
selector, or mutator; that makes the code short enough to really
inline. The inlined version takes about half the time of the
indirect version.
The compiler does not yet track bindings precisely enough to
recognize constants for sub-type declarations.
- lets other events be handled based on how long it has been
replaying the current trace (instead of based on the number of
pieces in the trace that have been seen)
- breaks up the syncheck:add-rename-menu pieces of the trace to
be more granular (to make the previous point work better)
This should make DrRacket more responsive when the trace is being
replayed
This fixes several issues:
- `Parameter` generates impersonator contracts correctly
- `Any` handling now copies immutable data when possible
- `Any` now recognizes more atomic base types
Merge to 5.3.1.
This reverts commit d39780a130.
Matthew says this test is really about TCP, so it should not be
changed. Although perhaps we can use a more basic TCP test to check if
this should be done.
so that no derivation data structure creation
happens during just a normal judgment-holds,
but this was not entirely successful, so there
still is some....
Also, improved the test-util to show stacktraces
for errors (when they exist)
