This removes all the SVG sources, parsing, and marked-layer colorizing, the PNG binaries in the distribution, and the dependence of DrRacket on `slideshow/pict'.
Icons are now produced by drawing on a bitmap-dc%, inferring or building a z map, choosing a material, and sending these to a two-pass ray tracer. This is for the most part hidden behind an API consisting of functions from colors and optional sizes and materials to `bitmap%'s.
Contracts and documentation forthcoming.
Previously, if a dispatched build failed the files from the previous
build would still get copied. This was an intentional feature, since
only the compiled binaries of these builds are used, and usually these
would work fine (with the zo files that were built on the main machine).
Now, the build directory is deleted when starting, which means that any
failure in a remote build means that the whole build will fail. This
turns out to be better since when there are problems, the previous
behavior could be very confusing. In addition, the racket setup itself
rarely fails, so this won't make a difference.
* Use `ssh' to copy the repo tgz, so it can also create the build
directory in a single connection.
* Use "racket" in the build materials directory name (since it's used in
random machines).
* Use `chcon' to make files accessible to the web server under selinux.
* "YYYY-MM-DD HH:MM" in log time strings (leave the one on the web page
as is).
* Uniform machine+platform labels in headers on dispatched builds. The
main build machine doesn't have them.
On dispatched builds the status is printed in their own logs in a
greppable way, and these lines are removed when these logs are displayed
as part of the main log.
be a frame and react to changes in focus of the main drracket window.
didn't finish because there does not seem to be an equivalent to
on-subwindow-focus that lets the frame detect when one of its
children gets the focus.
related to PR 12474
There is a big comment in thread.rkt that explains the problem and the
"fix". I think something better could and should be done, but I don't
know what it is.
This speeds up the lambdajs model considerably because the computation
to determine duplicates is expensive and no duplicates are really
ever dropped (and, in general, I think that duplicates will only
be dropped when the grammar is ambiguous; so maybe a better thing
is to just rewrite the grammar when that happens)
when one hole has been found
This improves the lambdajs model example's running time, presumably
because the hole is generally found near the "beginning" of the
term
Instead of using a hash-table, use the equal-hash-code directly;
this lets me evict entries only when they clobber each other,
and generally keep good cache utilization.
Also, cut the cache size by a factor of 5 while still having a
slight performance improvement on the r6rs test suite benchmark.
On that same benchmark, there are 1714812 misses in the cache, but
only 3485 times is an entry in the cache clobbered
have any holes, hide-holes, or names and, in that case, just
combining booleans instead of building of mtch structs.
This does seem to work on a simple benchmark. The code below
gets about 6x faster. But on the r6rs test suite, there is
no substantial change (possibly because the caching obviates
this optimization?)
lang racket/base
(require redex/reduction-semantics)
(caching-enabled? #f)
(define-language L (e (+ e e) number))
(define t
(let loop ([n 100])
(cond
[(zero? n) 1]
[else `(+ 11 ,(loop (- n 1)))])))
(define f (redex-match L e))
(time (for ([x (in-range 1000)]) (f t)))
When I enabled this, I don't see any speedup, on the R6RS test suite
benchmark (I see minor slowdown). Here are the numbers I get, on my
laptop:
nt cache: 35537 msec
neither: 844933 msec
Jay's idea: 875306 msec
And with both on, I see a similar, minor slowdown (as compared to the
version with the nt cache).
The main difference seems to be that I'm getting about 6 "hits" per
test case on the nt-match structs (that is, I avoid work by finding an
nt-match struct) and I'm getting about 8,800 hits in the cache per
test case.
This covers all of the html files in mailman's template directory, and
we should have a consistent look for all pages. (Including archived
messages.) Also tweak the front page to have a link to the mailman
"listinfo" page with the complete list of the hosted mailing lists.
Add a `resource/referrer' abstraction for referrers, on top of plain
resources. (When the referrer is `values', it just returns the plain
resource.) Also add `url-of' to replace `get-resource-path'.
This turned out to be a bad idea. The thing is that some resources need
to be referred to in multiple ways -- for example, different texts in
links of different kinds, or using the URL directly in some cases. The
existence of `get-resource-path' is a witness for this problem, since it
was used for such cases -- this function is removed as well.
There's no point in trying to generalize this here: instead, go back to
a simpler system where a resource always returns its URL (with an
optional argument to get an absolute URL). When a `referrer'
functionality is needed, build it on top of that, in a place where it
makes more sense. (That is, in a specific code for generating content,
where there could be a decision that resources have plain links and also
a very short link for use in navbars.) Otherwise, it's usually simpler
to just define resources and referrers separately (as different
bindings, the latter uses the former).
Turns out that bash's regexps (using `=~') changed so that quoting them
matches a literal string, and it seems dangerous to rely on parsing
unquoted regexps. One way around this is to put the regexp in a
variable, but for the two simple uses that this script had, it's easy to
avoid regexps completely.
redex patterns a bunch:
- repeats are turned into wrappers in sequences,
- names are all explicit,
- non-terminals are wrapped with `nt',
- cross patterns always have the hyphens in them.
- ellipses names are normalized (so there are no "hidden"
name equalities); this also means that repeat patterns
can have both a regular name and a mismatch name
Also, added a match-a-pattern helper macro that checks to make sure
that functions that process patterns don't miss any cases
to be a hierarchical-list-item<%> object, but now it is
a list of language names (same information, different data)
and one place didn't get updated.
Closes PR 12462
the purpose of drawing arrows.
The computation to fill in the cache seems to actually be pretty quick and
the work to clear the cache when it is out of date (via a call to on-change)
can be substantial on big files, so just not maintaining the cache seems better.
(there are 7254 arrows in drracket/private/unit.rkt, stored in an interval map,
and iterating over the interval-map in a for loop seems to be time consuming)
Also, DrRacket could get into a state where switching tabs would trigger a
call to on-change, which means that switching tabs would take a few seconds.
Using the old extension protocol for MysterX --- plus the hack of
a dummy source module for a kind of portability --- really should
be replaced with an FFI-based approach to the MysterX DLL.
* In base64 encoding remove all newlines from the encoded result, avoids
getting an invalid result.
* In qp encoding:
- replace all spaces by underlines, not just the first (looks like a
typo in the previous code)
- encode "?"s and "_"s too, as required for this encoding
- remove soft newlines (again, avoid an invalid result)
* Use `regexp-replace*' to encode the parts between the lines. Besides
making the code simpler, it fixes a bug in the previous code where
multiple lines would each get encoded and the results concatenated
without the newlines or any other whitespace.
* When the string to be encoded is longer than 70 characters, split and
encode the sub-parts, then concatenate the encodings with a "\n "
separator. This is done as a poor attempt to follow the line length
limits specified in rfc2047, or more concretely, to avoid sendmail's
"!\n " splitting.
* Use `re:non-ascii' to look for a non-ascii character => faster.
* Use either CR or LF for a newline, not just LF.
* Use `regexp-replace*' to encode the parts between the lines. Besides
making the code simpler, it fixes a bug in the previous code where
multiple lines would each get encoded and the results concatenated
without the newlines or any other whitespace.
There might be existing uses of `net/sendmail' that did this quoting
since this code didn't do so. Such uses would continue to work fine,
since quoted strings would already be plain ASCII, so a second quoting
would leave it as is.
Note that the quoted strings are also used as command line arguments.
It seems that sendmail deals with these all fine when they appear as
command line arguments. This means that any valid email address format
can be used, not just "raw" emails. If there are some sendmails that
don't do this, then it would be better to add a `-t' flag to let
sendmail parse the text in the message.
One caveat (not a new one): since they're passed as is, it is possible
to use two emails in a single string, as in "a@b.com, c@d.com". This
could lead to obvious problems if someone uses "Bar, Foo <foo@bar.org>"
instead of "\"Bar, Foo\" <foo@bar.org>". (Using a `-t' to parse the
content won't help with that...) The only way to avoid this would be to
parse the emails and quote the name part if needed. But that's a much
hairier piece of code.
* Move the `X-Mailer' header to the top, so that the interesting headers
are all together at the bottom (the top gets littered by server
headers anyway).
* Use `subprocess' directly (`process*' wasn't really doing anything
more than that).
* Allow the sender to be `#f', leaving the header out. This makes all
sendmails that I've used use the username that is running the process.
* Just search for a sendmail program: don't barf on windows, so it can
be used in case there is a sendmail.exe executable there.
* Remove `no-mail-recipients' to make it in-line with other racket code
that doesn't raise super-specific exceptions.
* Use port counting instead of doing the counts manually, much simpler
code.
Namely, not the singular record signature, but the signature
constructors of `define-record-procedures-parametric'.
(We'd done this before, but that patch got reverted, without the
doc part getting reinstated.)
Such as this, submitted by Torsten Grust:
(define-record-procedures-parametric stream_ stream-of
make-stream
stream?
(stream-head stream-tail))
(define stream
(lambda (t)
(signature (stream-of t (-> (stream t))))))
(: from (number -> (stream number)))
(define from
(lambda (n)
(make-stream n (lambda () (from (+ n 1))))))
(: foo (stream number))
(define foo (from 1))
The problem was that the arbitaries got evaluated too eagerly.
the state that online check syntax uses (indirectly via scribble)
to lookup documentation.
since the kill-safe abstraction moved some computation over to
another thread, the values of various parameters (current-directory
in this case) were not preserved. So when scribble then ended up
resolving a module path with the wrong current directory, this
bad value got cached. Then later, when check syntax tries to figure
out what file to open to jump to it, it got the cached bogus value
(even though current-directory was right when check syntax asked
for the filename).
closes PR 12538
Rename `read-intern-literal' to `datum-intern-literal'.
Interning is needed only in `read-syntax' or `datum->syntax' to
set up the invariants that the bytecode compiler needs for cross-module
optimization. When `read'ing numbers from a data file, meanwhile,
interning slows things down a lot and doesn't seem worthwhile.
This library is used by Redex, which wants a `syntax'-like template
language, but for datum values instead of syntax objects. Using
`datum-case' and `datum' generates much less code. Redex uses
only a small part of the general functionality, so adding
`syntax/datum' could be overkill. It's implemented by generalizing
the `syntax-case' and `syntax' pattern matching and template
constructing code, though; it's not a lot of extra code, and it's
easiest to generalize completely. We may find other uses for
datum templates, too.
The value isn't used; a 'dep tag is ony to establish
dependencies, and the relevant value is with a 'form or
'def tag. Avoiding the extra value saves another 5% in
cross-reference files.
This change saves a small amount of space in cross-reference files
and some space in loaded cross-reference information.
It also saves work converting strings to mutable on deserialize,
although the performance difference seems negligible.
when doing typesetting stuff in Redex, as the former seems to have
some kind of context dependency that makes it insert ||s around
some upper-case symbols sometimes
cope with the case where the thread has been killed (the nacks are
apparently not triggered on thread death in some cases)
(optimistically) closes PR 12427
The over-eager transformation could be space-unsafe, and it
could duplicate an unsafe operation whose result is used only
once in a function that eds up being inlined multiple times.
In @defform*[#:id x1 [(qqq x1)]], for example, `#:id x1' needs to
calcel the default treatment of `x1' within `(qqq x1)' as
a metavariable, while treating `qqq' as a meta-variable.
The code seems to pre-date the failure thunk to `syntax-local-value'.
A problem with letting an exception get raised is that it triggers
the `error-value->string' handler, which loads Slideshow pict support
in DrRacket, which loads `racket/draw' at phase 1 --- which isn't
inherenty bad, but a lot of work that can be avoided.
coordinates, or not, depending on the arity of that function. This
enables one to write a simple function from color -> color and
immediately map it on an image. For the situation in which the
function is location-dependent, one can still write a function from
x,y,color -> color and map this on the image.
Calling this function:
(provide
(contract-out
[f (-> integer? integer?)]))
(define (f x) x)
from another module seems to speed up by about 8% with the annotation
in this commit.
More generally, support a
(define _id (begin 'compiler-hint:cross-module-inline _proc-expr))
hint, which is how the compiler determines that `map', etc., are
candidates for inlining.
