to gc:cons and gc:closure instead of passing locs
This enables the important change, namely that get-root-set
no longer returns roots corresponding to the arguments
of the allocation function that we're in the middle of.
This means that a common error students have (forgetting
to chase the 'hd' and 'tl' pointers in their GC) is
harder to make now, since get-root-set never contains
those locations as roots. (In the past you would have had
to write some pretty non-obvious mutator program to get
that behavior.)
* See comment about implementation issues.
* Removed the `list?' requirement on `takef' etc -- so it matches the
non-*f versions. (IMO, it'd be better to drop it from all of them.)
This also changes the output of `dropf' to `any/c'.
* Swapped the argument order so the predicate is last -- this makes it
uniform with the non-f* versions. (IMO, it'b be better to use the
popular order in all of them instead.)
* Includes tests, and also improved version of previous tests.
* Includes docs, and also fixes to previous docs (eg, drop* doesn't
return a fresh list).
As a side-effect of this fix, we don't need the thunking behavior for
external identifiers anymore. Even better!
Also include some other cleanups suggested by Ryan and moves from
quasisyntax/loc -> syntax/loc where we don't use the quasiquoting.
generate so much code
(Mostly to avoid pain with the macro stepper, but also
reducing the amount of code macros generates is good
for performance reasons)
The code used to avoid lifting identifier in more restricted circumstances,
but it seems safe to alway avoid that, which can lead to a lot
less lifting
This is mostly to better support test cases so that we
can set up namespaces that have specific collectors in them
(easiest to do with quote-based requires)
There's still a function application (here, a thunk) lurking in
external accesses, but since that's a trade-off for an entire contract
application, we profit.
This pushes almost all uses of check below into tc-expr and
tc-expr/check. This means that the optimizer sees more precise types
and can make more optimizations.
The `interactive' pict constructor is a hook for interactive GUI
elements on a slide. The callback associated with an `interactive'
pict gets a `frame%' instance for a frame that floats over the pict.
No need to stick with the srfi-1 style of `lis' and `recur'. I also
removed the srfi-1 comment since this code is straightforward. (I keep
such comments if there's something non-trivial that was taken.)
This test started failing due to the additions of the calls
to clip, introduced in commit e6dc9c28b4. The actual
difference is only 9 pixels out of about 100,000 relevant
pixels. Even better, here's the precise rgb values for the
mis-matched pixels (the alpha values don't change):
(224 251 255) vs (229 255 255)
(200 242 255) vs (205 247 255)
(205 242 255) vs (210 247 255)
(205 242 255) vs (210 247 255)
(205 242 255) vs (210 247 255)
(205 242 255) vs (210 247 255)
(200 242 255) vs (205 247 255)
(224 251 255) vs (229 255 255)
(242 255 255) vs (247 255 255)
It isn't clear to me why clipping like this would have this
particular change, but I think it is safe to assume that
Redex shouldn't change in response to this!
- enable generation for the above by compiling to
a disequation with "#f"
- wrap bare terms in relation definitons in
side-conditions (require they not be "#f")
That is, when right-clicking on an imported identifier, if the
file that has that identifier's definition is open and online
check syntax has completed, then offer a "jump to definition" menu
item that just jumps there with the already computed informtion.
If the file isn't open or online check syntax hasn't completed,
instead offer just to go to the file, without jumping to the definition
also
- things should generally work slightly better with submodules
- jumping to identifiers should do a better job with scrolling,
specifically it should scroll so the jumped-to identifier is
about 20% from the top of the window (unless it was already visible,
in which case no scrolling should occur)
It used to just kind of give up processing which, from the outside,
watching looked like
(begin-for-syntax (custodian-shutdown-all (current-custodian)))
and so fell into that case in the code. Now, by explicitly raising
an exception, we get a more accurate response
The revised implementation is more clearly and directly expressed
in terms of table cells that span columns.
Also, avoid `panorama' by removing a useless `inset' that seems
likely to be the reason for the `panorama'.
Unix bitmaps to go with the new tests are missing; Robby plans to
add them.
* Check `sandbox-path-permissions' for bad values such as
'(<perm> <path1> <path2>) where <path2> would get silently ignored.
* Try to clarify the intent of `call-in-sandbox-context' as a meta tool
rather than a safe execution tool.
Using an impersonator property to represent an application mark was
a bad choice. The property gets propagated, so it is also on any later
chaperone layer, and then things go bad: the docs say that special
treatment is triggered by supplying an argument to `impersonate-property',
but it was actually triggered by the chaperone having the property.
Change the implementation to match the documentation. Using an
impersonator property to supply the mark should be regarded as a hack,
but now the implementaiton is at least consistent with the documentaiton.
- put the tests together with the other define-union-language tests
- fix the docs
- add a release note
- construct the merged language a bit more directly
- properly deal with this kind of thing:
(define-language L1 (e f ::= 1 2 3))
(define-language L2 (e g ::= 4 5 6))
(define-union-language L L1 L2)
This ensures that `=>` and `else` have the same bindings as the ones in
`racket/private/cond`; otherwise it would not be possible to use SRFI 61
`cond` from a `#lang racket/base` program/module.
Tested under both `#lang racket` and `#lang mzscheme`.
This is a bit suspicious, since it isn't clear why a frame
whose show method has been called with #f should be considered
an active frame. Since changing that is a much more dangerous
change then, for now: closes PR 13564
This commit is to giure out just how much Rackety can combat rightward drift
in this file (this was a region of code edited recently for other reasons)
Turns out that the first hunk's rightmost column (of code, not counting
comments) moved left by 39 chars and the second by 40 chars
Specifically, when expanding in the body of a dependent argument, put
the original variable for the dependened on field into that code, but
changing the expansion so that the binder becomes the original field's
x, not the x in the dependent declaration list.
This means that, for example, in this program:
(->i ([x any/c]
[y (x) (begin x any/c)]
[z (x) (begin x any/c)]) any)
the first x will be the binder and the other four now count as
bound occurrences.
Also, rip off Casey's redex check syntax tests to add tests
closes PR 13559
The intent is to support phase-crossing data such as the `exn:fail:syntax'
structure type that is instantiaed by macros and recognized by contexts
that use `eval' or `expand'. Phaseless modules are highly constrained,
however, to avoid new cross-phase channels, and a module is inferred to
be phaseless when it fits syntactic constraints.
I've adjusted `racket/kernel' and improved its documentation a little
so that it can be used to implement a phaseless module (which can
import only from other phaseless modules).
This change also adds a `flags' field to the `mod' structure type
from `compiler/zo-structs'.
* The all-versions page has a docs column with html/pdf links, and also
two links in the nightly builds footer.
* Specific version download pages have a link to the docs for that
version. (Only html, to save space.)
* Move sha1 test to the same place, to be run like the others.
* Unify tests for untar and unzip.
* Also improve them: test results instead of failing with errors. Also,
generate random text to archive, and use 0 for group+other permission
bits (to avoid world writable results on an error).
Also, minor code cleanup (don't create a function and pass it
around when has only one thing in its closure and you can
just pass that around, especially when passing the function around
makes the code harder to read and the created function has to
have a "dot" arglist and use "apply" in its body)
better wrt to its first result
That is, instead of just returning the string "#lang" it now
returns the actual text that was there (it was supposed to be
doing that all along and my recent commit fixed it, but I
missed the test cases)
lexers it defers to
also, remove the checks in color.rkt in the framework (they are not
all covered by the added contract, but they mostly are and when they
aren't, most of those times are using the heavily tested racket-lexer)
- sllgen.rkt - use begin-for-syntax+define-syntax instead of
define-syntax-set.
- eopl.scrbl - rewrite *3-columns so that it no longer errors when 3
doesn't divide the number of reprovided lang forms.
- Removal of mzscheme and mzlib requires.
- Updated docs.
This adds a tag to DrRacket File menu docs. It adds two margin notes
to the quick start, one linking to the essentials for using DrRacket,
and the other for saving Definitions.
Addresses PR 9501.
same information as the yellow green bubbles
Before, when you typed c:x;n, drracket would look at the identifier
you're on, find its binder, find all bound occurrences of that binder,
sort them by position in the buffer, and then jump to the one that
follows where you are.
This works great for things like the "x" in "(let ([x 1]) x x)"
but not so great for things like the "define" in:
#lang racket
(define x '(+ 1 2))
(define y '(+ 3 4))
since that would jump to the quote, since there are bindign arrows
going from the "racket" to the define and to the quote.
Now, since it is using information ultimately derived directly
from (and only from) free-identifier=? (the arrows also come from
identifier-binding, which is how we get those arrows in the second
example above) you jump from the first define to the second define,
which seems better.
Pango crashes (with an assertion failure) on characters U+1D173
through U+1D17A. Trying to fix (or even just compile) Pango for
Windows is hard, so skip the characters at the `draw-text' and
`text-extent' level.
The bug is unlikely to be specific to just those characters in the
long run, but only those characters appear to be problematic on my
Windows 7 installation. So, the workaround may be enough for many
installations, and hopefully the Pango bug wil be fixed one day.
Relevant to PR 13513
A recent change improved "on this page" handling and also
fixed a short-circuit test to almost certainly do what
was originally intended, but the test was wrong, so just
get rid of it.
Related to PR 13305: I tried to use zero-width-space to force appropriate
line breaks, but unfortunately under Opera on Linux, this shows as
unsupported character glyphs.
Since I can't reliably use zero-width-space, I'm backtracking to the
prior solution on introducing spans with the mywbr class. However,
I've added in a   element to the content of the span, as suggested
elsewhere on the web. This appears to fix the _gcpointer issue that
Eric sees.
These additions could create backward-compatibility problems, but our
searches suggest that problems will be rare; it's more common for
`_size_t' to be incorrectly aliased to `_int', so having definitions
for these standard types is likely to avoid future problems.
commit e503850f21 broke drracket's
interactivity (for some files it could take 2 seconds to do
that one line)
This changes the bindings-table so that it maps to sets instead of
lists. Now, instead of mutating all entries in the table right after
collecting everything, just leave them as sets until we need the info
and just sort a single entry, when it is needed
The check was incomplete in the case that both arguments to a binary
[ext]flonum function need to be checked and the second one was not an
[ext]flonum and also not a fixnum.
The problem was exposed by improved error checking
in the expander to detect references to exports of a module that
is not yet visited, and as triggered by the documentation for
`2htdp/planetcute'.
A part with style property 'toc-hidden no longer
hides child sections, which makes it consistent with Latex/PDF
rendering.
A part with style 'grouper and 'unnumbered does not make its
child parts render as more nested, which is consistent with
'gruper without 'unnumbered. An unnumbered grouper is represented
as "" in a section-number list (while #f is still used for
unnumbered non-grouper layers).
Includes a repair for floating-point `min' and `max' that affects all
x86 builds that use SSE arithmetic, leaving the (otherwise unused)
floating-point stack in a bad state, which might have affected
x87-using C/foreign libraries running alongside Racket.
in the line numbers when it moves around
specifically, if the before and after green line are right
next to each other, then put it into a single edit sequence
(which unions the invalidated regions); if not, then we
may be jumping far away, so invalidate the two regions
and redraw them separately
wrap/handle-evt that receives multiple values must have a handler function with adequate arity.
struct.c:
change contract for wrap/handle-evt from (any/c -> any) to procedure?
thread.c:
adjust sync processing
sync.rktl:
add test for handle-evt, wrap-evt and prop:evt
Repair 73e07f576b added an item to a list without incrementing a
counter for the list length, which cause a different element of
the list to be dropped, which could mess up binding resolution in
arbitrarily bad ways.
(Ths bug falls into the "how did this not get exposed earlier?" bin,
although part of the answer is that it requires a combination of
module re-expansion and simplification of syntax objects in the
residual program.)
Closes PR 13428
This fixes a bug in DrRacket where by changing the font size
would cause the line numbers to encroach on the space allotted
to the main text of the definitions window (or, if the font size
is getting smaller, make a large gap)
Also, some cleanups of the code and
make the syntax-color/ library docs
point to color:text<%> instead of
color:text% (as the interesting information
is attached to the interface, not the class)
The previous version of the code replaced the implicit #%app with
the kernel #%app (ie, #%plain-app), causing sequence functions
that take keyword arguments to fail.
Instad of `(dynamic-require .. #f)', use `(dynamic-require .. 0)', which
has the effect of making compile-time code "available" (see docs) in
case the loaded module uses `eval' on syntax objects that refer to
non-kernel syntax.
closes PR 13489.
In the C code, inflate is allowed to peek at least one character
beyond the extent of a deflated byte sequence. The thread related to
the bug report of PR 13489 documents that deflate can peek beyond EOF.
Specifically when there is no delegate and an edit
sequence is started, track that differently in case
a delegate is set before the edit sequence ends
(in which case we don't want to end the edit
sequence in the delegate since we didn't start it
there)
related to PR 13491
Instead of assumning that the snip's text will match a font's height
metrics, check and remember the actual metrics if its doesn't match,
which accomodates font substitions (e.g., when using #\u2144 under
Windows).
This is, afaict, a completely backwards compatible way to add this
functionality in the sense that any of the non-error command-line
arguments passed to raco test before still do precisely the same
things
After some consultation with my class this quarter,
it seems clear that the previous defaults and nearby
variations are completely hopeless for colorblind people
(there are at least 3 in this class). So go with the
defaults used in the HtDP languages, which have been
vetted by saidsame 3 people.
binding site (with a green/yellow bubble) when the mouse moves over
any one of them
This change comes about because of the recent fixes to the
interactivity wrt to the rename menu. Basically, in order to fix the
bug (but still preserve the interactivity optimization), check syntax
changed from sending the information "here is a place to offer a
rename for these identifiers" to "here is a set of identifiers that
are all free-identifier=?" (the difference being that the latter does
not imply you got them all (which enables the optimization) and that
the information is slightly less rename-menu specific (which enables
the change in this commit))
An extflonum is like a flonum, but with 80-bit precision and
not a number in the sense of `number?': only operations such as
`extfl+' work on extflonums, and only on platforms where extflonums
can be implemented by hardware without interefering with flonums
(i.e., on platforms where SSE instructions are used for
double-precision floats).
[Patch provided by Michael Filonenko and revised by Matthew.]
The compiler tracks information about bindings that are known to
hold extflonums, but the JIT does not yet exploit this information
to unbox them (except as intermediate results).
Note: With this refactoring, `math/utils' no longer depends on `rackunit'.
* (flexp2 x) computes (flexpt 2.0 x) but in about 1/3 the time for integer
`x' using a lookup table. Written for exact argument reduction in `fllog2'
after discovering that (flexpt 2.0 x) was the main performance bottleneck.
* (fllog2 x) computes (/ (fllog x) (fllog 2.0)) with near perfect accuracy.
Invented an algorithm to compute it with at least 8 extra bits before
final rounding; quite pleased with the result. Needed `fllog2' to ensure
(fllogb 2.0 x) would be exact when `x' is a power of two.
* (fllogb b x) computes (/ (fllog x) (fllog b)) with better accuracy, and
also handles limit values in a way that's consistent with the mathematical
limits. When those are ambiguous, it's consistent with `flexpt', which
follows IEEE 754 and C99. Otherwise returns +nan.0. See docs for details.
* `bflogb' is currently just for testing `fllogb'.
* Refactored FPU testing and documented it. So far, the only documented way
to do it is by calling `test-floating-point', which runs a comprehensive
deterministic+randomized suite of tests and returns a list representing
failed tests. I'll document individual tests after I document flonum
expansions and result/error functions like `fl+/error'.
* Added `fllog2' and `fllogb' to the flonum tests.
The code used eq? to check to see if a given language was in
an list of allowed-to-create-executables languages. But the
language object was passing thru TR and so eq? didn't hold and
thus the check was buggy.
They hypothesis behind this change is that the undo is
undoing an edit that came before, not the temporary edit
that appears in insert-close-paren. So, when there are
no edits happening (ie when fixup? is #f) then don't
undo. This is only a hypothesis because we were not able
to find a small code sequence, outside of DrRacket to
cause the bad behavior, so possibly there is really more
going on here.
Thanks to Nadeem Abdul Hamid for finding this fix.
Closes PR 13454
