Enable extflonums in a MSVC build by relying on a MinGW-built DLL,
"longdouble.dll". The DLL is loaded on startup. If the DLL isn't
available, then `extflonum-available?' reports #f.
Instead of setting the floating-point mode globally to extended
precision, the mode is changed only just before (and restored right
after) extflonum arithmetic operations.
when it compiles required files
Now that this is fixed, the compilation manager will be (once again)
active when doing online compilation, so if the "Populate compiled
directories" checkbox is check (which it is by default) in the details
section of the language dialog, then online compilation will, as it
compiles your file, write out .zo files that will also be used by the
Run button.
The actual fix to this bug is the change in expanding-place.rkt (and
all it really does is move the setting of the
current-load/use-compiled and current-load parameters earlier so that
CM sees only the modified parameter settings and so doesn't give up on
compilation.
The rest of the changes are a test case (and change to drracket to
support the test case)
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)
