First use of the function was determining a single arity for
the enclosing module, and that arity could trigger warnings
in addition to failures to inline. For example, using `map'
on 3 arguments would trigger incorrect warnings for later
uses of `map' on 2 arguments.
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.
