Since keyword definitions expand into multiple defines, and inserting
the contract and external id definitions at the wrong point will cause
those to break, we handle define manually.
Hat-tip to Vincent for the idea.
Doing this means that we can't put a single splicing-syntax-parameterize
around the entire body, since it'll expand defines before we reach them,
so instead we add them around the expanded code.
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
This move moves a library from the plt distribution into the
mr distribution, which is a direction we do not generally
like to go, but the pict library is more core than slideshow
and the dependency that triggered this change is that the
2htdp/image library now interoperates with picts (hopefully
2htdp/universe will also work with them at some point).
So this teases out the pict part of slideshow (mostly,
but not completely the texpict collection) and moves only
that part to the mr distribution.
The code to draw a border has to determine the widget's position
within the drawing window. Gtk 3.0 has a function to provide that
transformation, but Gtk 2.0 doesn't seem to have one, and it seems
that the transformation implemented in `racket/gui' wasn't right.
Closes PR 13453
The code added to handle expressions mixed with definitions was
not introduced in the right way; fix it to be like macro-introduced
code.
Closes PR 13452
Clean up the use of styles for alignment and the generated instances
of style names. In the process, remove some padding for HTML output,
and make the rendering more configurable (especially for Latex, based
on suggestions by Keven Tew).
The way that nested flows are generated can be different than before,
so these changes risk breaking some existing uses of `scriblib/figure'.
The changes especially likely break uses of `scriblib/figure' with
output configured through overiding .css/.tex definitions. But
the old pile of styles/macros was inconsistent and broken in various
ways, so hopefully the changes are an improvement overall.
Nothing in the docs said that `parser-tools/yacc' is for LALR grammars
--- although I guess that it implied for most reader by the name "yacc",
but it doesn't hurt to say so explicitly. Meanwhile,
`parser-tools/cfg-parser' is useful for non-ambigious (non-LALR) grammars.
Also, from the style guide:
* Section Titles Should be In Titlecase, Like This
* Don't start a setence with an uncapitalized identifier.
This guarantees that patterns like (? pred pat) will
always check `pred` before matching any of `pat`.
However, `and` patterns are not required to match left-
to-right.
The fix consists of three parts:
1. Rewriting `inline-matrix*'. The material change here is that the
expansion now contains only direct applications of `+' and `*'.
TR's optimizer replaces them with `unsafe-fx+' and `unsafe-fx*',
which keeps intermediate flonum values from being boxed.
2. Making the types of all functions that operate on (Matrix Number)
values more precise. Now TR can prove that matrix operations preserve
inexactness. For example, matrix-conjugate : (Matrix Flonum) ->
(Matrix Flonum) and three other cases for Real, Float-Complex, and
Number.
3. Changing the return types of some functions that used to return
things like (Matrix (U A 0)). Now that we worry about preserving
inexactness, we can't have `matrix-upper-triangle' always return a
matrix that contains exact zeros. It now accepts an optional `zero'
argument of type A.
Strip any code signing when generating an executable from
Racket or GRacket. Also, place the __LINKEDIT segment in
virtual memory after the __PLTSCHEME segment, so that
the in-memory layout order matches the file layout order,
which in turn makes the code-signing tool's update of the
__LINKEDIT segment's size not create a virtual-memory
overlap with __PLTSCHEME.
* Narrowed type of `submatrix' to only sensible argument types
* `matrix-invertible?' now returns #f when given a non-square matrix
instead of raising an error
* Allowed `matrix-diagonal' to operate on non-square matrices
