suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

change Scribble to complain about colliding tags

Browse Source 
svn: r8025
This commit is contained in:
Matthew Flatt 2007-12-16 03:10:00 +00:00
parent 8f463ff1c4
commit fd1de94a48
30 changed files with 287 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
collects/net/doc/sendmail.scrbl
View File

@ -39,13 +39,13 @@ that the sendmail process can complete.
The @scheme[from] argument can be any value; of course, spoofing The @scheme[from] argument can be any value; of course, spoofing
should be used with care.} should be used with care.}
@defproc[(send-mail-message/port [from string?] @defproc[(send-mail-message [from string?]
[subject string?] [subject string?]
[to (listof string?)] [to (listof string?)]
[cc (listof string?)] [cc (listof string?)]
[bcc (listof string?)] [bcc (listof string?)]
[body (listof string?)] [body (listof string?)]
[extra-header string?] ...) [extra-header string?] ...)
void?]{ void?]{
Like @scheme[send-mail-message/port], but with @scheme[body] as a list Like @scheme[send-mail-message/port], but with @scheme[body] as a list

323
collects/scheme/private/kw.ss
View File

@ -10,7 +10,7 @@
"norm-define.ss" "norm-define.ss"
"qqstx.ss")) "qqstx.ss"))
(#%provide new-lambda (#%provide new-lambda new-λ
new-define new-define
new-app new-app
(rename *make-keyword-procedure make-keyword-procedure) (rename *make-keyword-procedure make-keyword-procedure)
@ -280,165 +280,168 @@
#f "bad argument sequence" stx (syntax args))])))) #f "bad argument sequence" stx (syntax args))]))))
;; The new `lambda' form: ;; The new `lambda' form:
(define-syntax (new-lambda stx) (define-syntaxes (new-lambda new-λ)
(syntax-case stx () (let ([new-lambda
[(_ args body1 body ...) (lambda (stx)
(if (simple-args? #'args) (syntax-case stx ()
;; Use plain old `lambda': [(_ args body1 body ...)
(syntax/loc stx (if (simple-args? #'args)
(lambda args body1 body ...)) ;; Use plain old `lambda':
;; Handle keyword or optional arguments: (syntax/loc stx
(with-syntax ([((plain-id ...) (lambda args body1 body ...))
(opt-id ...) ;; Handle keyword or optional arguments:
([id opt-expr kind] ...) (with-syntax ([((plain-id ...)
([kw kw-id kw-req] ...) (opt-id ...)
need-kw ([id opt-expr kind] ...)
rest) ([kw kw-id kw-req] ...)
(parse-formals stx #'args)]) need-kw
(let ([dup-id (check-duplicate-identifier (syntax->list #'(id ... . rest)))]) rest)
(when dup-id (parse-formals stx #'args)])
(raise-syntax-error (let ([dup-id (check-duplicate-identifier (syntax->list #'(id ... . rest)))])
#f (when dup-id
"duplicate argument identifier" (raise-syntax-error
stx #f
dup-id))) "duplicate argument identifier"
(let* ([kws (syntax->list #'(kw ...))] stx
[opts (syntax->list #'(opt-id ...))] dup-id)))
[ids (syntax->list #'(id ...))] (let* ([kws (syntax->list #'(kw ...))]
[plain-ids (syntax->list #'(plain-id ...))] [opts (syntax->list #'(opt-id ...))]
[kw-reqs (syntax->list #'(kw-req ...))] [ids (syntax->list #'(id ...))]
[kw-args (generate-temporaries kws)] ; to hold supplied value [plain-ids (syntax->list #'(plain-id ...))]
[kw-arg?s (generate-temporaries kws)] ; to indicated whether it was supplied [kw-reqs (syntax->list #'(kw-req ...))]
[opt-args (generate-temporaries opts)] ; supplied value [kw-args (generate-temporaries kws)] ; to hold supplied value
[opt-arg?s (generate-temporaries opts)] ; whether supplied [kw-arg?s (generate-temporaries kws)] ; to indicated whether it was supplied
[needed-kws (sort (syntax->list #'need-kw) [opt-args (generate-temporaries opts)] ; supplied value
(lambda (a b) (keyword<? (syntax-e a) (syntax-e b))))] [opt-arg?s (generate-temporaries opts)] ; whether supplied
[sorted-kws (sort (map list kws kw-args kw-arg?s kw-reqs) [needed-kws (sort (syntax->list #'need-kw)
(lambda (a b) (keyword<? (syntax-e (car a)) (lambda (a b) (keyword<? (syntax-e a) (syntax-e b))))]
(syntax-e (car b)))))]) [sorted-kws (sort (map list kws kw-args kw-arg?s kw-reqs)
(with-syntax ([(kw-arg ...) kw-args] (lambda (a b) (keyword<? (syntax-e (car a))
[(kw-arg? ...) (let loop ([kw-arg?s kw-arg?s] (syntax-e (car b)))))])
[kw-reqs kw-reqs]) (with-syntax ([(kw-arg ...) kw-args]
(cond [(kw-arg? ...) (let loop ([kw-arg?s kw-arg?s]
[(null? kw-arg?s) null] [kw-reqs kw-reqs])
[(not (syntax-e (car kw-reqs))) (cond
(cons (car kw-arg?s) (loop (cdr kw-arg?s) (cdr kw-reqs)))] [(null? kw-arg?s) null]
[else (loop (cdr kw-arg?s) (cdr kw-reqs))]))] [(not (syntax-e (car kw-reqs)))
[kws-sorted sorted-kws] (cons (car kw-arg?s) (loop (cdr kw-arg?s) (cdr kw-reqs)))]
[(opt-arg ...) opt-args] [else (loop (cdr kw-arg?s) (cdr kw-reqs))]))]
[(opt-arg? ...) opt-arg?s] [kws-sorted sorted-kws]
[(new-plain-id ...) (generate-temporaries #'(plain-id ...))] [(opt-arg ...) opt-args]
[new-rest (if (null? (syntax-e #'rest)) [(opt-arg? ...) opt-arg?s]
'() [(new-plain-id ...) (generate-temporaries #'(plain-id ...))]
'(new-rest))] [new-rest (if (null? (syntax-e #'rest))
[(rest-id) (if (null? (syntax-e #'rest)) '()
'(()) '(new-rest))]
#'rest)] [(rest-id) (if (null? (syntax-e #'rest))
[rest-empty (if (null? (syntax-e #'rest)) '(())
'() #'rest)]
'(null))]) [rest-empty (if (null? (syntax-e #'rest))
(let ([with-core '()
(lambda (result) '(null))])
;; body of procedure, where all keyword and optional (let ([with-core
;; argments come in as a pair of arguments (value and (lambda (result)
;; whether the value is valid): ;; body of procedure, where all keyword and optional
(syntax-property ;; argments come in as a pair of arguments (value and
(quasisyntax/loc stx ;; whether the value is valid):
;; We need to push the certificates way down, so that (syntax-property
;; the `class' macro (for example) can pull it apart (quasisyntax/loc stx
;; enough to insert an additional argument. ;; We need to push the certificates way down, so that
(let #,(syntax-property ;; the `class' macro (for example) can pull it apart
#`(#,(syntax-property ;; enough to insert an additional argument.
#`[core (let #,(syntax-property
#,(syntax-property #`(#,(syntax-property
#`(lambda #,(syntax-property #`[core
#`(given-kws given-args #,(syntax-property
new-plain-id ... #`(lambda #,(syntax-property
opt-arg ... #`(given-kws given-args
opt-arg? ... new-plain-id ...
. new-rest) opt-arg ...
'certify-mode opt-arg? ...
'transparent) . new-rest)
;; sort out the arguments into the user-supplied bindings, 'certify-mode
;; evaluating default-values expressions as needed: 'transparent)
(let-kws given-kws given-args kws-sorted ;; sort out the arguments into the user-supplied bindings,
(let-maybe ([id opt-expr kind] ... . rest) ;; evaluating default-values expressions as needed:
(kw-arg ...) (kw-arg? ...) (let-kws given-kws given-args kws-sorted
(opt-arg ...) (opt-arg? ...) (let-maybe ([id opt-expr kind] ... . rest)
(new-plain-id ... . new-rest) (kw-arg ...) (kw-arg? ...)
;; the original body, finally: (opt-arg ...) (opt-arg? ...)
body1 body ...))) (new-plain-id ... . new-rest)
'certify-mode ;; the original body, finally:
'transparent)] body1 body ...)))
'certify-mode 'certify-mode
'transparent)) 'transparent)]
'certify-mode 'certify-mode
'transparent) 'transparent))
;; entry points use `core': 'certify-mode
#,result)) 'transparent)
'certify-mode ;; entry points use `core':
'transparent))] #,result))
[mk-no-kws 'certify-mode
(lambda () 'transparent))]
;; entry point without keywords: [mk-no-kws
(syntax/loc stx (lambda ()
(opt-cases (core null null) ([opt-id opt-arg opt-arg?] ...) (plain-id ...) ;; entry point without keywords:
() (rest-empty rest-id . rest) (syntax/loc stx
())))] (opt-cases (core null null) ([opt-id opt-arg opt-arg?] ...) (plain-id ...)
[mk-with-kws () (rest-empty rest-id . rest)
(lambda () ())))]
;; entry point with keywords: [mk-with-kws
(if (and (null? opts) (lambda ()
(null? #'new-rest)) ;; entry point with keywords:
#'core (if (and (null? opts)
(syntax/loc stx (null? #'new-rest))
(opt-cases (core) ([opt-id opt-arg opt-arg?] ...) (given-kws given-args plain-id ...) #'core
() (rest-empty rest-id . rest) (syntax/loc stx
()))))] (opt-cases (core) ([opt-id opt-arg opt-arg?] ...) (given-kws given-args plain-id ...)
[mk-kw-arity-stub () (rest-empty rest-id . rest)
(lambda () ()))))]
;; struct-type entry point for no keywords when a keyword is required [mk-kw-arity-stub
(syntax/loc stx (lambda ()
(fail-opt-cases (missing-kw) (opt-id ...) (self plain-id ...) ;; struct-type entry point for no keywords when a keyword is required
() (rest-id . rest) (syntax/loc stx
())))]) (fail-opt-cases (missing-kw) (opt-id ...) (self plain-id ...)
(cond () (rest-id . rest)
[(null? kws) ())))])
;; just the no-kw part (cond
(with-core (mk-no-kws))] [(null? kws)
[(null? needed-kws) ;; just the no-kw part
;; both parts dispatch to core (with-core (mk-no-kws))]
(with-core [(null? needed-kws)
(with-syntax ([kws (map car sorted-kws)] ;; both parts dispatch to core
[no-kws (let ([p (mk-no-kws)] (with-core
[n (syntax-local-infer-name stx)]) (with-syntax ([kws (map car sorted-kws)]
(if n [no-kws (let ([p (mk-no-kws)]
#`(let ([#,n #,p]) #,n) [n (syntax-local-infer-name stx)])
p))] (if n
[with-kws (mk-with-kws)]) #`(let ([#,n #,p]) #,n)
(syntax/loc stx p))]
(make-optional-keyword-procedure [with-kws (mk-with-kws)])
with-kws (syntax/loc stx
null (make-optional-keyword-procedure
'kws with-kws
no-kws))))] null
[else 'kws
;; just the keywords part dispatches to core, no-kws))))]
;; and the other part dispatches to failure [else
(with-core ;; just the keywords part dispatches to core,
(with-syntax ([kws (map car sorted-kws)] ;; and the other part dispatches to failure
[needed-kws needed-kws] (with-core
[no-kws (mk-no-kws)] (with-syntax ([kws (map car sorted-kws)]
[with-kws (mk-with-kws)] [needed-kws needed-kws]
[mk-id (with-syntax ([n (syntax-local-infer-name stx)] [no-kws (mk-no-kws)]
[call-fail (mk-kw-arity-stub)]) [with-kws (mk-with-kws)]
(syntax-local-lift-expression [mk-id (with-syntax ([n (syntax-local-infer-name stx)]
#'(make-required 'n call-fail)))]) [call-fail (mk-kw-arity-stub)])
(syntax/loc stx (syntax-local-lift-expression
(mk-id #'(make-required 'n call-fail)))])
with-kws (syntax/loc stx
'needed-kws (mk-id
'kws))))]))))))])) with-kws
'needed-kws
'kws))))]))))))]))])
(values new-lambda new-lambda)))
(define (missing-kw proc . args) (define (missing-kw proc . args)
(apply (apply

2
collects/scheme/private/pre-base.ss
View File

@ -30,7 +30,7 @@
(all-from "define.ss") (all-from "define.ss")
(all-from-except "letstx-scheme.ss" -define -define-syntax -define-struct) (all-from-except "letstx-scheme.ss" -define -define-syntax -define-struct)
(rename new-lambda lambda) (rename new-lambda lambda)
(rename new-lambda λ) (rename new-λ λ)
(rename new-define define) (rename new-define define)
(rename new-app #%app) (rename new-app #%app)
(rename #%app #%plain-app) (rename #%app #%plain-app)

10
collects/scribble/base-render.ss
View File

@ -119,11 +119,11 @@
(hash-table-for-each (collect-info-ht p-ci) (hash-table-for-each (collect-info-ht p-ci)
(lambda (k v) (lambda (k v)
(when (cadr k) (when (cadr k)
(hash-table-put! (collect-info-ht ci) (collect-put! ci
(if prefix (if prefix
(convert-key prefix k) (convert-key prefix k)
k) k)
v))))))) v)))))))
(define/private (convert-key prefix k) (define/private (convert-key prefix k)
(case (car k) (case (car k)

2
collects/scribble/manual.ss
View File

@ -780,7 +780,7 @@
(table? (car (splice-run box))) (table? (car (splice-run box)))
(eq? 'boxed (table-style (car (splice-run box))))) (eq? 'boxed (table-style (car (splice-run box)))))
(error 'deftogether "element is not a boxing splice containing a single table: ~e" box)) (error 'deftogether "element is not a boxing splice containing a single table: ~e" box))
(list (make-flow (list (make-table #f (table-flowss (car (splice-run box)))))))) (list (make-flow (list (make-table "together" (table-flowss (car (splice-run box))))))))
boxes)) boxes))
(parameterize ([current-variable-list (parameterize ([current-variable-list
(apply append (map box-splice-var-list boxes))]) (apply append (map box-splice-var-list boxes))])

4
collects/scribble/scribble.css
View File

@ -253,6 +253,10 @@
background-color: #E8E8FF; background-color: #E8E8FF;
} }
.together {
width: 100%;
}
.prototype td { .prototype td {
vertical-align: top; vertical-align: top;
} }

9
collects/scribble/struct.ss
View File

@ -15,9 +15,12 @@
(define (collect-put! ci key val) (define (collect-put! ci key val)
(hash-table-put! (collect-info-ht ci) (let ([ht (collect-info-ht ci)])
key (when (hash-table-get ht key #f)
val)) (fprintf (current-error-port)
"WARNING: collected information for key multiple times: ~e\n"
key))
(hash-table-put! ht key val)))
(define (resolve-get/where part ri key) (define (resolve-get/where part ri key)
(let ([key (tag-key key ri)]) (let ([key (tag-key key ri)])

34
collects/scribblings/gui/editor-overview.scrbl
View File

@ -82,11 +82,11 @@ Now, the standard cut and paste operations work, and the user can even
on the outside of the box is rearranged as the box changes on the outside of the box is rearranged as the box changes
sizes. Note that the box itself can be copied and pasted. sizes. Note that the box itself can be copied and pasted.
The content of an editor is made up of @deftech{snips}. An embedded The content of an editor is made up of @defterm{@tech{snips}}. An
editor is a single snip from the embedding editor's point-of-view. To embedded editor is a single snip from the embedding editor's
encode immediate text, a snip can be a single character, but more point-of-view. To encode immediate text, a snip can be a single
often a snip is a sequence of adjacent characters on the same character, but more often a snip is a sequence of adjacent characters
line. The @method[text% find-snip] method extracts a snip on the same line. The @method[text% find-snip] method extracts a snip
from a text editor: from a text editor:
@schemeblock[ @schemeblock[
@ -396,15 +396,15 @@ Graceful and extensible encoding of snips requires that
@item{Some editors may require additional information to be stored @item{Some editors may require additional information to be stored
about a snip; this information is orthogonal to the type-specific about a snip; this information is orthogonal to the type-specific
information stored by the snip itself. For example, a pasteboard information stored by the snip itself. For example, a pasteboard
needs to remember a snip's @techlink{location}, while a text editor does not needs to remember a snip's @techlink{location}, while a text editor
need this information. If data is being cut and pasted from one does not need this information. If data is being cut and pasted from
pasteboard to another, then information about relative @techlink{location}s one pasteboard to another, then information about relative
needs to be maintained, but this information should not inhibit @techlink{location}s needs to be maintained, but this information
pasting into an editor. Extra data is associated with a snip through should not inhibit pasting into an editor. Extra data is associated
@deftech{editor data} objects, instances of the with a snip through @deftech{editor data} objects, which are
@scheme[editor-data%] class; decoding requires that each editor data instances of the @scheme[editor-data%] class; decoding requires that
object has an @deftech{editor data class}, an instance of the each editor data object has an @deftech{editor data class}, which is
@scheme[editor-data-class%] class.} an instance of the @scheme[editor-data-class%] class.}
} }
@ -415,7 +415,7 @@ Snip classes, snip data, and snip data classes solve problems related
@subsubsection[#:tag "editorsnipclasses"]{Snip Classes} @subsubsection[#:tag "editorsnipclasses"]{Snip Classes}
Each snip can be associated to a @deftech{snip class}. This ``class'' Each snip can be associated to a @tech{snip class}. This ``class''
is not a class description in the programmer's language; it is an is not a class description in the programmer's language; it is an
object which provides a way to create new snips of the appropriate object which provides a way to create new snips of the appropriate
type from an encoded snip specification. type from an encoded snip specification.
@ -455,12 +455,12 @@ A snip class's name can also be just @scheme["(lib ...)"], which is
While a snip belongs to an editor, the editor may store extra While a snip belongs to an editor, the editor may store extra
information about a snip in some specialized way. When the snip is to information about a snip in some specialized way. When the snip is to
be encoded, this extra information needs to be put into an be encoded, this extra information needs to be put into an
@deftech{editor data} object so that the extra information can be @tech{editor data} object so that the extra information can be
encoded as well. In a text editor, extra information can be encoded as well. In a text editor, extra information can be
associated with ranges of @techlink{item}s, as well as snips. associated with ranges of @techlink{item}s, as well as snips.
Just as a snip must be associated with a snip class to be decoded (see Just as a snip must be associated with a snip class to be decoded (see
@|snipclassdiscuss|), an editor data object needs an @deftech{editor @|snipclassdiscuss|), an editor data object needs an @tech{editor
data class} for decoding. Every editor data class object can be added data class} for decoding. Every editor data class object can be added
to the eventspace-specific @deftech{editor data class list}, returned to the eventspace-specific @deftech{editor data class list}, returned
by @scheme[get-the-editor-data-class-list]. Alternatively, like snip by @scheme[get-the-editor-data-class-list]. Alternatively, like snip

6
collects/scribblings/gui/guide.scrbl
View File

@ -8,17 +8,17 @@ For documentation purposes, the MrEd toolbox is organized into three
@itemize{ @itemize{
@item{The @deftech{windowing} toolbox, for implementing form-filling @item{The @deftech{windowing toolbox}, for implementing form-filling
GUI programs (such as a database query window) using buttons, menus, GUI programs (such as a database query window) using buttons, menus,
text fields, and events. The windowing toolbox is described in text fields, and events. The windowing toolbox is described in
@secref["windowing-overview"].} @secref["windowing-overview"].}
@item{The @deftech{drawing} toolbox, for drawing pictures or @item{The @deftech{drawing toolbox}, for drawing pictures or
implementing dynamic GUI programs (such as a video game) using implementing dynamic GUI programs (such as a video game) using
drawing canvases, pens, and brushes. The drawing toolbox is drawing canvases, pens, and brushes. The drawing toolbox is
described in @secref["drawing-overview"].} described in @secref["drawing-overview"].}
@item{The @deftech{editor} toolbox, for developing traditional text @item{The @deftech{editor toolbox}, for developing traditional text
editors, editors that mix text and graphics, or free-form layout editors, editors that mix text and graphics, or free-form layout
editors (such as a word processor, HTML editor, or icon-based file editors (such as a word processor, HTML editor, or icon-based file
browser). The editor toolbox is described in browser). The editor toolbox is described in

12
collects/scribblings/gui/win-overview.scrbl
View File

@ -109,7 +109,7 @@ In addition to dispatching events, the GUI classes also handle the
graphical layout of windows. Our example frame demonstrates a simple graphical layout of windows. Our example frame demonstrates a simple
layout; the frame's elements are lined up top-to-bottom. In general, layout; the frame's elements are lined up top-to-bottom. In general,
a programmer specifies the layout of a window by assigning each GUI a programmer specifies the layout of a window by assigning each GUI
element to a parent @deftech{container}. A vertical container, such element to a parent @tech{container}. A vertical container, such
as a frame, arranges its children in a column, and a horizontal as a frame, arranges its children in a column, and a horizontal
container arranges its children in a row. A container can be a child container arranges its children in a row. A container can be a child
of another container; for example, to place two buttons side-by-side of another container; for example, to place two buttons side-by-side
@ -296,9 +296,9 @@ Menu bars, menus, and menu items are graphical elements, but not areas
@item{@scheme[separator-menu-item%] --- a @deftech{separator} is @item{@scheme[separator-menu-item%] --- a @deftech{separator} is
an unselectable line in a menu or popup menu.} an unselectable line in a menu or popup menu.}
@item{@scheme[menu-item%] --- a @deftech{menu item} is a selectable @item{@scheme[menu-item%] --- a @deftech{plain menu item} is a
text item in a menu. When the item is selected, its callback procedure selectable text item in a menu. When the item is selected, its
is invoked.} callback procedure is invoked.}
@item{@scheme[checkable-menu-item%] --- a @deftech{checkable menu @item{@scheme[checkable-menu-item%] --- a @deftech{checkable menu
item} is a text item in a menu; the user selects a checkable menu item} is a text item in a menu; the user selects a checkable menu
@ -405,7 +405,7 @@ Each @tech{containee}, or child, has the following properties:
@item{horizontal and vertical @deftech{stretchability} (on or off); and} @item{horizontal and vertical @deftech{stretchability} (on or off); and}
@item{horizontal and vertical @deftech{margins}.} @item{horizontal and vertical @tech{margins}.}
} }
@ -822,7 +822,7 @@ Although a programmer has no direct control over the order in which
@subsection[#:tag "espacethreads"]{Eventspaces and Threads} @subsection[#:tag "espacethreads"]{Eventspaces and Threads}
When a new eventspace is created, a corresponding @deftech{handler When a new eventspace is created, a corresponding @tech{handler
thread} is created for the eventspace. When the system dispatches an thread} is created for the eventspace. When the system dispatches an
event for an eventspace, it always does so in the eventspace's event for an eventspace, it always does so in the eventspace's
handler thread. A handler procedure can create new threads that run handler thread. A handler procedure can create new threads that run

10
collects/scribblings/gui/wxme.scrbl
View File

@ -435,7 +435,7 @@ special comment contains the comment text.}
A text-mode reader for XML boxes.}] A text-mode reader for XML boxes.}]
@defclass[comment-editor% editor% (readable<%>)]{ @defclass[xml-editor% editor% (readable<%>)]{
Instantiated for DrScheme XML boxes in a @tech{WXME} stream for text Instantiated for DrScheme XML boxes in a @tech{WXME} stream for text
mode. mode.
@ -469,7 +469,7 @@ Scheme boxes.}
A text-mode reader for Scheme boxes.}] A text-mode reader for Scheme boxes.}]
@defclass[comment-editor% editor% (readable<%>)]{ @defclass[scheme-editor% editor% (readable<%>)]{
Instantiated for DrScheme Scheme boxes in a @tech{WXME} stream for text Instantiated for DrScheme Scheme boxes in a @tech{WXME} stream for text
mode. mode.
@ -493,15 +493,15 @@ Generates an S-expression for the code in the box.}
@section{DrScheme Text Boxes} @section{DrScheme Text Boxes}
@defmodule[wxme/scheme] @defmodule[wxme/text]
@in[wxme/scheme @in[wxme/text
@defthing[reader (is-a?/c snip-reader<%>)]{ @defthing[reader (is-a?/c snip-reader<%>)]{
A text-mode reader for text boxes.}] A text-mode reader for text boxes.}]
@defclass[comment-editor% editor% (readable<%>)]{ @defclass[text-editor% editor% (readable<%>)]{
Instantiated for DrScheme text boxes in a @tech{WXME} stream for text Instantiated for DrScheme text boxes in a @tech{WXME} stream for text
mode. mode.

2
collects/scribblings/guide/guide.scrbl
View File

@ -92,7 +92,7 @@ printed output.
@; ---------------------------------------------------------------------- @; ----------------------------------------------------------------------
@section[#:tag "macros"]{Reader Extension} @section[#:tag "reader"]{Reader Extension}
@; ---------------------------------------------------------------------- @; ----------------------------------------------------------------------
@section[#:tag "security"]{Security} @section[#:tag "security"]{Security}

4
collects/scribblings/guide/namespaces.scrbl
View File

@ -93,8 +93,8 @@ initial module mapping, further modules can be loaded.
A namespace created with @scheme[make-base-empty-namespace] is A namespace created with @scheme[make-base-empty-namespace] is
suitable for many basic dynamic tasks. For example, suppose that a suitable for many basic dynamic tasks. For example, suppose that a
@schememodname[my-dsl] library implements a domain-specific language in @schememodfont{my-dsl} library implements a domain-specific language
which you want to execute commands from a user-specified file. A in which you want to execute commands from a user-specified file. A
namespace created with @scheme[make-base-empty-namespace] is enough to namespace created with @scheme[make-base-empty-namespace] is enough to
get started: get started:

2
collects/scribblings/inside/ports.scrbl
View File

@ -815,7 +815,7 @@ is made if @var{copy} is not 0. The string @var{bytes} should contain
nul terminator in addition. If @var{len} is negative, then the nul terminator in addition. If @var{len} is negative, then the
nul-terminated length of @var{bytes} is used for the length.} nul-terminated length of @var{bytes} is used for the length.}
@function[(Scheme_Object* scheme_make_sized_path @function[(Scheme_Object* scheme_make_sized_offset_path
[char* bytes] [char* bytes]
[long d] [long d]
[long len] [long len]

13
collects/scribblings/quick/quick.scrbl
View File

@ -517,12 +517,13 @@ interfaces. The API for Scheme's GUI and graphics system is expressed
in terms of objects and classes. in terms of objects and classes.
The class system itself is implemented by the The class system itself is implemented by the
@schememodname[scheme/class] library, and the @schememodname[mred] @schememodname[scheme/class] library, and the
library provides the GUI and drawing classes. By convention, the MrEd @schememodname[scheme/gui/base] library provides the GUI and drawing
classes are given names that end with @scheme[%]: classes. By convention, the classes are given names that end with
@scheme[%]:
@mr-defs+int[ @mr-defs+int[
[(require scheme/class mred) [(require scheme/class scheme/gui/base)
(define f (new frame% [label "My Art"] (define f (new frame% [label "My Art"]
[width 300] [width 300]
[height 300] [height 300]
@ -539,8 +540,8 @@ such as @scheme[show], with arguments after the method name; the
argument @scheme[#t] in this case is the boolean constant ``true.'' argument @scheme[#t] in this case is the boolean constant ``true.''
Pictures generated with @schememodname[slideshow] encapsulate a Pictures generated with @schememodname[slideshow] encapsulate a
function that uses MrEd's drawing commands to render the picture to a function that uses the graphics toolbox's drawing commands to render
drawing context, such as a canvas in a frame. The the picture to a drawing context, such as a canvas in a frame. The
@scheme[make-pict-drawer] function from @schememodname[slideshow] @scheme[make-pict-drawer] function from @schememodname[slideshow]
exposes a picture's drawing function. We can use exposes a picture's drawing function. We can use
@scheme[make-pict-drawer] in a canvas-painting callback to draw a @scheme[make-pict-drawer] in a canvas-painting callback to draw a

7
collects/scribblings/reference/class.scrbl
View File

@ -90,10 +90,11 @@ A @deftech{class} specifies
} }
An @deftech{object} is a collection of bindings for fields that are In the context of the class system, an @defterm{object} is a
instantiated according to a class description. collection of bindings for fields that are instantiated according to a
class description.
The object system allows a program to define a new class (a The class system allows a program to define a new class (a
@deftech{derived class}) in terms of an existing class (the @deftech{derived class}) in terms of an existing class (the
@deftech{superclass}) using inheritance, overriding, and augmenting: @deftech{superclass}) using inheritance, overriding, and augmenting:

2
collects/scribblings/reference/control-lib.scrbl
View File

@ -16,7 +16,7 @@ work sensibly together. Many are redundant; for example,
@deftogether[( @deftogether[(
@defform[(% expr)] @defform[(% expr)]
@defform[(% expr handler-expr)] @defform/none[(% expr handler-expr)]
@defproc[(fcontrol [v any/c]) any] @defproc[(fcontrol [v any/c]) any]
)]{ )]{

2
collects/scribblings/reference/encodings.scrbl
View File

@ -76,7 +76,7 @@ UTF-8 for encoding.
@defparam[current-locale locale (or/c string? false/c)]{ @defparam[current-locale locale (or/c string? false/c)]{
A parameter that determines the current @deftech{locale} for A parameter that determines the current @tech{locale} for
procedures such as @scheme[string-locale-ci=?]. procedures such as @scheme[string-locale-ci=?].
When locale sensitivity is disabled by setting the parameter to When locale sensitivity is disabled by setting the parameter to

6
collects/scribblings/reference/help.scrbl
View File

@ -17,9 +17,9 @@ arguments. It is not provided by @scheme[scheme] or
@deftogether[( @deftogether[(
@defidform[help] @defidform[help]
@defform[(help id)] @defform/none[(help id)]
@defform[(help id #:from module-path)] @defform/none[(help id #:from module-path)]
@defform[(help #:search datum ...)] @defform/none[(help #:search datum ...)]
)]{ )]{
Searches the documentation, and opens a web browser (using the user's Searches the documentation, and opens a web browser (using the user's

15
collects/scribblings/reference/memory.scrbl
View File

@ -9,13 +9,14 @@
A @deftech{weak box} is similar to a normal box (see A @deftech{weak box} is similar to a normal box (see
@secref["boxes"]), but when the garbage collector (see @secref["boxes"]), but when the garbage collector (see
@secref["gc-model"]) can prove that the content value of a weak box @secref["gc-model"]) can prove that the content value of a weak box is
is only reachable via weak references, the content of the weak box is only reachable via weak references, the content of the weak box is
replaced with @scheme[#f]. A @deftech{weak reference} is a reference replaced with @scheme[#f]. A @defterm{@tech{weak reference}} is a
through a weak box, through a key reference in a weak hash table (see reference through a weak box, through a key reference in a weak hash
@secref["hashtables"]), through a value in an ephemeron where the table (see @secref["hashtables"]), through a value in an ephemeron
value can be replaced by @scheme[#f] (see @secref["ephemerons"]), or where the value can be replaced by @scheme[#f] (see
through a custodian (see @secref["custodians"]). @secref["ephemerons"]), or through a custodian (see
@secref["custodians"]).
@defproc[(make-weak-box [v any/c]) weak-box?]{ @defproc[(make-weak-box [v any/c]) weak-box?]{

2
collects/scribblings/reference/port-lib.scrbl
View File

@ -2,7 +2,7 @@
@require["mz.ss" @require["mz.ss"
(for-label scheme/port)] (for-label scheme/port)]
@title[#:tag "customport"]{More Port Constructors and Events} @title{More Port Constructors and Events}
@note-lib[scheme/port] @note-lib[scheme/port]

4
collects/scribblings/reference/stx-certs.scrbl
View File

@ -10,8 +10,8 @@ module name (see @secref["modpathidx"]), an @tech{inspector} (see
is attached as either an @deftech{active certificate} or an is attached as either an @deftech{active certificate} or an
@deftech{inactive certificate}. @deftech{inactive certificate}.
The @scheme[datum->syntax] procedure never transfers an The @scheme[datum->syntax] procedure never transfers an @tech{active
@deftech{active certificate} from one syntax object to another. The certificate} from one syntax object to another. The
@scheme[syntax-recertify] procedure can be used to transfer a @scheme[syntax-recertify] procedure can be used to transfer a
certificate from one syntax object to another, but only if the certificate from one syntax object to another, but only if the
certificate's key is provided, or if a sufficiently powerful inspector certificate's key is provided, or if a sufficiently powerful inspector

2
collects/scribblings/reference/stx-expand.scrbl
View File

@ -1,7 +1,7 @@
#lang scribble/doc #lang scribble/doc
@require["mz.ss"] @require["mz.ss"]
@title[#:tag "expansion"]{Expanding Top-Level Forms} @title{Expanding Top-Level Forms}
@defproc[(expand [top-level-form any/c]) syntax?]{ @defproc[(expand [top-level-form any/c]) syntax?]{

21
collects/scribblings/reference/stx-props.scrbl
View File

@ -98,19 +98,18 @@ information on properties and byte codes.
@;------------------------------------------------------------------------ @;------------------------------------------------------------------------
@defproc[(syntax-property [stx syntax?][key any/c][v any/c]) @defproc*[([(syntax-property [stx syntax?][key any/c][v any/c])
syntax?]{ syntax?]
[(syntax-property [stx syntax?][key any/c]) any])]{
Extends @scheme[stx] by associating an arbitrary property value The three-argument form extends @scheme[stx] by associating an
@scheme[v] with the key @scheme[key]; the result is a new syntax arbitrary property value @scheme[v] with the key @scheme[key]; the
object with the association (while @scheme[stx] itself is unchanged).} result is a new syntax object with the association (while @scheme[stx]
itself is unchanged).
The two-argument form returns an arbitrary property value associated
@defproc[(syntax-property [stx syntax?][key any/c]) any]{ to @scheme[stx] with the key @scheme[key], or @scheme[#f] if no value
is associated to @scheme[stx] for @scheme[key].}
Returns an arbitrary property value associated to @scheme[stx] with
the key @scheme[key], or @scheme[#f] if no value is associated to
@scheme[stx] for @scheme[key].}
@defproc[(syntax-property-symbol-keys [stx syntax?]) list?]{ @defproc[(syntax-property-symbol-keys [stx syntax?]) list?]{

2
collects/scribblings/reference/syntax-model.scrbl
View File

@ -458,7 +458,7 @@ time, rather than run time (though the two times can overlap), though
the binding itself is introduced with @tech{phase level} 0 (i.e., in the binding itself is introduced with @tech{phase level} 0 (i.e., in
the @tech{base environment}). the @tech{base environment}).
The @deftech{value} for the binding is obtained by evaluating the The @tech{value} for the binding is obtained by evaluating the
expression in the @scheme[define-syntaxes] form. This expression must expression in the @scheme[define-syntaxes] form. This expression must
be @tech{expand}ed (i.e. parsed) before it can be evaluated, and it is be @tech{expand}ed (i.e. parsed) before it can be evaluated, and it is
expanded at @tech{phase level} 1 (i.e., in the @tech{transformer expanded at @tech{phase level} 1 (i.e., in the @tech{transformer

4
collects/scribblings/reference/syntax.scrbl
View File

@ -331,7 +331,7 @@ the procedure body.
(let ([f (lambda (x #:arg y) (list y x))]) (let ([f (lambda (x #:arg y) (list y x))])
(list (f 1 #:arg 2) (list (f 1 #:arg 2)
(f #:arg 2 1))) (f #:arg 2 1)))
]} ]
When compiling a @scheme[lambda] or @scheme[case-lambda] expression, When compiling a @scheme[lambda] or @scheme[case-lambda] expression,
Scheme looks for a @indexed-scheme['method-arity-error] property Scheme looks for a @indexed-scheme['method-arity-error] property
@ -343,7 +343,7 @@ will hide the first argument, if one was provided. (Hiding the first
argument is useful when the procedure implements a method, where the argument is useful when the procedure implements a method, where the
first argument is implicit in the original source). The property first argument is implicit in the original source). The property
affects only the format of @scheme[exn:fail:contract:arity] affects only the format of @scheme[exn:fail:contract:arity]
exceptions, not the result of @scheme[procedure-arity]. exceptions, not the result of @scheme[procedure-arity].}
@defform/subs[(case-lambda [formals body ...+] ...) @defform/subs[(case-lambda [formals body ...+] ...)

16
collects/scribblings/reference/thread-cells.scrbl
View File

@ -3,8 +3,8 @@
@title[#:tag "threadcells"]{Thread Cells} @title[#:tag "threadcells"]{Thread Cells}
A @deftech{thread cell} contains a thread-specific value; that is, it A @defterm{@tech{thread cell}} contains a thread-specific value; that
contains a specific value for each thread, but it may contain is, it contains a specific value for each thread, but it may contain
different values for different threads. A thread cell is created with different values for different threads. A thread cell is created with
a default value that is used for all existing threads. When the cell's a default value that is used for all existing threads. When the cell's
content is changed with @scheme[thread-cell-set!], the cell's value content is changed with @scheme[thread-cell-set!], the cell's value
@ -12,12 +12,12 @@ changes only for the current thread. Similarly,
@scheme[thread-cell-ref] obtains the value of the cell that is @scheme[thread-cell-ref] obtains the value of the cell that is
specific to the current thread. specific to the current thread.
A thread cell's value can be @deftech{preserved}, which means that A thread cell's value can be @defterm{@tech{preserved}}, which means
when a new thread is created, the cell's initial value for the new that when a new thread is created, the cell's initial value for the
thread is the same as the creating thread's current value. If a thread new thread is the same as the creating thread's current value. If a
cell is non-preserved, then the cell's initial value for a newly thread cell is non-preserved, then the cell's initial value for a
created thread is the default value (which was supplied when the cell newly created thread is the default value (which was supplied when the
was created). cell was created).
Within the current thread, the current values of all preserved threads Within the current thread, the current values of all preserved threads
cells can be captured through cells can be captured through

16
collects/scribblings/scribble/how-to.scrbl
View File

@ -49,7 +49,7 @@ EOS
@item{Run @exec{setup-plt} to build your documentation. For a @item{Run @exec{setup-plt} to build your documentation. For a
collection, optionally supply @Flag{l} followed by the collection, optionally supply @Flag{l} followed by the
collection name to limit the build process to the collection.} collection name to limit the build process to that collection.}
@item{The generated documentation is @item{The generated documentation is
@filepath{compiled/doc/manual/index.html} within the @filepath{compiled/doc/manual/index.html} within the
@ -57,9 +57,9 @@ EOS
If you want the output to be relative to the PLT Scheme If you want the output to be relative to the PLT Scheme
documentation directory (which is recommend only for those who documentation directory (which is recommend only for those who
produce the ``official'' PLT Scheme distribution), add the produce the ``official'' PLT Scheme distribution, and even
@scheme['main-doc] option to the @scheme[scribblings] then only in certain cases), add the @scheme['main-doc] option
definition in @filepath{info.ss}.} to the @scheme[scribblings] definition in @filepath{info.ss}.}
} }
@ -92,14 +92,14 @@ one must be present. No spaces are allowed between
A @nonterm{cmd} or @nonterm{datum} is a Scheme datum, while a A @nonterm{cmd} or @nonterm{datum} is a Scheme datum, while a
@nonterm{text-body} is itself in text mode. @nonterm{text-body} is itself in text mode.
The expansion of a @litchar["@"] form into Scheme code is The expansion of @litchar["@"]@nonterm{cmd} into Scheme code is
@schemeblock[ @schemeblock[
@nonterm{cmd} #, @nonterm{cmd}
] ]
if neither @litchar["["] @litchar["]"] nor @litchar["{"] @litchar["}"] When either @litchar["["] @litchar["]"] or @litchar["{"] @litchar["}"]
are used, otherwise are used, the expansion is
@schemeblock[ @schemeblock[
(#, @nonterm{cmd} #, @kleenestar{@nonterm{datum}} #, @kleenestar{@nonterm{parsed-body}}) (#, @nonterm{cmd} #, @kleenestar{@nonterm{datum}} #, @kleenestar{@nonterm{parsed-body}})

4
collects/scribblings/scribble/manual.scrbl
View File

@ -662,7 +662,7 @@ output, a hyperlink underline appears even when the mouse is not over
the link.} the link.}
@; ------------------------------------------------------------------------ @; ------------------------------------------------------------------------
@section{Indexing} @section[#:tag "manual-indexing"]{Indexing}
@defform[(indexed-scheme datum ...)]{ @defform[(indexed-scheme datum ...)]{
@ -801,7 +801,7 @@ correspond to the documented name of the binding and the primary
modules that export the documented name (but this list is not modules that export the documented name (but this list is not
exhaustive, because new modules can re-export the binding).} exhaustive, because new modules can re-export the binding).}
@defstruct[(procedure-index-desc exported-index-desc) ()]{ @defstruct[(form-index-desc exported-index-desc) ()]{
Indicates that the index entry corresponds to the definition of a Indicates that the index entry corresponds to the definition of a
syntactic form via @scheme[defform] and company.} syntactic form via @scheme[defform] and company.}

6
collects/scribblings/slideshow/slides.scrbl
View File

@ -377,6 +377,12 @@ Parameter that controls the amount of space used between lines by
@scheme[para], @scheme[item], and @scheme[subitem].} @scheme[para], @scheme[item], and @scheme[subitem].}
@defparam[current-para-width n nonnegative-exact-integer?]{
Parameter that controls the width of a pict created by
@scheme[para], @scheme[item], and @scheme[subitem].}
@defparam[current-title-color color (or/c string? (is-a?/c color%))]{ @defparam[current-title-color color (or/c string? (is-a?/c color%))]{
Parameter used by the default @scheme[current-titlet] to colorize the Parameter used by the default @scheme[current-titlet] to colorize the