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

Some random tidyings.

Browse Source
This commit is contained in:
Eli Barzilay 2011-02-16 15:26:11 -05:00
parent 8886b87876
commit 1be26400cb
7 changed files with 1279 additions and 1531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

239
collects/scribblings/drracket/prefs.scrbl
View File

@ -9,22 +9,25 @@
The preferences dialog consists of several panels. The preferences dialog consists of several panels.
@section{@onscreen{Font}} @section{@onscreen{Font}}
This panel controls the main font used by DrRacket. This panel controls the main font used by DrRacket.
@section{@onscreen{Colors}} @section{@onscreen{Colors}}
The @onscreen{Colors} panel has several sub-panels that let you The @onscreen{Colors} panel has several sub-panels that let you
configure the colors that DrRacket uses for the editor background, configure the colors that DrRacket uses for the editor background, for
for highlighting matching parentheses, for the online coloring for highlighting matching parentheses, for the online coloring for Racket
Racket and Java modes, for @onscreen{Check Syntax}, and for the and Java modes, for @onscreen{Check Syntax}, and for the colors of the
colors of the text in the @tech{interactions window}. text in the @tech{interactions window}.
It also has two buttons, @onscreen{White on Black} and @onscreen{Black
on White}, which set a number of defaults for the color preferences and
change a few other aspects of DrRacket's behavior to make DrRacket's
colors look nicer for those two modes.
It also has two buttons, @onscreen{White on Black} and
@onscreen{Black on White}, which set a number of defaults for the
color preferences and change a few other aspects of DrRacket's
behavior to make DrRacket's colors look nicer for those two modes.
@section{@onscreen{Editing}} @section{@onscreen{Editing}}
@ -39,76 +42,78 @@ The preferences dialog consists of several panels.
@item{@onscreen{Square bracket} @item{@onscreen{Square bracket}
This panel controls which keywords DrRacket uses to determine This panel controls which keywords DrRacket uses to determine when
when to rewrite @litchar["["] to @litchar["("]. For to rewrite @litchar["["] to @litchar["("]. For @racket[cond]-like
@racket[cond]-like keywords, the number in parenthesis indicates keywords, the number in parenthesis indicates how many
how many sub-expressions are skipped before square brackets are sub-expressions are skipped before square brackets are started.
started.
See @secref["editor"] for details on how the entries in the See @secref["editor"] for details on how the entries in the
columns behave.} columns behave.}
@item{@onscreen{General} @item{@onscreen{General}
@itemize[@item{@PrefItem{Map delete to backspace} --- If checked, the editor
@itemize[
@item{@PrefItem{Map delete to backspace} --- If checked, the editor
treats the Delete key like the Backspace key.} treats the Delete key like the Backspace key.}
@item{@PrefItem{Wrap words in editor buffers} --- If checked, @item{@PrefItem{Wrap words in editor buffers} --- If checked,
DrRacket editors auto-wrap text lines by default. Changing this DrRacket editors auto-wrap text lines by default. Changing
preference affects new windows only.} this preference affects new windows only.}
@item{@PrefItem{Reuse existing frames when opening new files} --- @item{@PrefItem{Reuse existing frames when opening new files} ---
If checked, new files are opened in the same DrRacket window, If checked, new files are opened in the same DrRacket
rather than creating a new DrRacket window for each new file.} window, rather than creating a new DrRacket window for each
new file.}
@item{@PrefItem{Enable keybindings in menus} --- If checked, some @item{@PrefItem{Enable keybindings in menus} --- If checked, some
DrRacket menu items have keybindings. Otherwise, no menu items DrRacket menu items have keybindings. Otherwise, no menu
have key bindings. This preference is designed for people who are items have key bindings. This preference is designed for
comfortable editing in Emacs and find the standard menu people who are comfortable editing in Emacs and find the
keybindings interfere with the Emacs keybindings.} standard menu keybindings interfere with the Emacs
keybindings.}
@item{@PrefItem{Treat command key as meta} --- If checked,
@item{@PrefItem{Treat command key as meta} --- If checked, DrRacket will use the command key for some Emacs-like keybindings, instead of using it for menu shortcuts. This option is only available under Mac OS X.} DrRacket will use the command key for some Emacs-like
keybindings, instead of using it for menu shortcuts. This
@item{@PrefItem{Color syntax interactively} --- If checked, DrRacket option is only available under Mac OS X.}
colors your syntax as you type.} @item{@PrefItem{Color syntax interactively} --- If checked,
DrRacket colors your syntax as you type.}
@item{@PrefItem{Search using anchors} --- If checked, DrRacket's searching mode will jump directly to the first search hit, using an ``anchor'' to determine where to search if the search string changes.} @item{@PrefItem{Search using anchors} --- If checked, DrRacket's
searching mode will jump directly to the first search hit,
@item{@PrefItem{Normalize pasted strings} --- If checked, DrRacket adjusts strings that are pasted into the editor to avoid confusion. For example, non-breaking spaces look just like spaces but are not considered separators like ordinary spaces are. If this is checked DrRacket will automatically turn those non-breaking spaces into regular spaces. Similarly with other (less common) characters.} using an ``anchor'' to determine where to search if the
search string changes.}
@item{@PrefItem{Enable overwrite mode keybindings} --- If checked, DrRacket enables the insert keybinding to swap into overwrite mode} @item{@PrefItem{Normalize pasted strings} --- If checked, DrRacket
adjusts strings that are pasted into the editor to avoid
@item{@PrefItem{Show line numbers} --- If checked, DrRacket shows line numbers for the file being edited in the left-hand column} confusion. For example, non-breaking spaces look just like
spaces but are not considered separators like ordinary
]} spaces are. If this is checked DrRacket will automatically
turn those non-breaking spaces into regular spaces.
Similarly with other (less common) characters.}
@item{@PrefItem{Enable overwrite mode keybindings} --- If checked,
DrRacket enables the insert keybinding to swap into
overwrite mode}
@item{@PrefItem{Show line numbers} --- If checked, DrRacket shows
line numbers for the file being edited in the left-hand
column}]}
@item{@onscreen{Racket} @item{@onscreen{Racket}
@itemize[ @itemize[
@item{@PrefItem{Highlight between matching parens} --- If checked,
the editor marks the region between matching parenthesis
with a gray background (in color) or a stipple pattern (in
monochrome) when the blinking caret is next to a
parenthesis.}
@item{@PrefItem{Automatically adjust closing parens} --- If
checked, the editor automatically converts a typed
@litchar[")"] to @litchar["]"] to match @litchar["["], or it
converts a typed @litchar["]"] to @litchar[")"] to match
@litchar["("].}
@item{@PrefItem{Automatically adjust opening square brackets} If
checked, the editor changes typed @litchar["["] to match the
context (as explained in @secref["editor"]).}
@item{@PrefItem{Flash paren match} --- If checked, typing a
closing parenthesis, square bracket, or quotation mark
flashes the matching open parenthesis/bracket/quote.}]}
@item{@PrefItem{Highlight between matching parens} --- If checked, the ]
editor marks the region between matching parenthesis with a gray
background (in color) or a stipple pattern (in monochrome) when
the blinking caret is next to a parenthesis.}
@item{@PrefItem{Automatically adjust closing parens} --- If checked, the editor
automatically converts a typed @litchar[")"] to @litchar["]"] to
match @litchar["["], or it converts a typed @litchar["]"] to
@litchar[")"] to match @litchar["("].}
@item{@PrefItem{Automatically adjust opening square brackets} If checked, the editor changes
typed @litchar["["] to match the context (as explained in
@secref["editor"]).}
@item{@PrefItem{Flash paren match} --- If checked, typing a closing
parenthesis, square bracket, or quotation mark flashes the
matching open parenthesis/bracket/quote.}
]}]
@section{@onscreen{Warnings}} @section{@onscreen{Warnings}}
@ -122,41 +127,41 @@ The preferences dialog consists of several panels.
user before exiting.} user before exiting.}
@item{@PrefItem{Ask about normalizing strings} --- If checked, DrRacket @item{@PrefItem{Ask about normalizing strings} --- If checked, DrRacket
consults the user before normalizing a string pasted into the editor.} consults the user before normalizing a string pasted into the
editor.}
@item{@PrefItem{Only warn once when executions and interactions are @item{@PrefItem{Only warn once when executions and interactions are not
not synchronized} --- If checked, DrRacket warns the user on the synchronized} --- If checked, DrRacket warns the user on the first
first interaction after the definitions window, language, or interaction after the definitions window, language, or teachpack
teachpack is changed without a corresponding click on is changed without a corresponding click on @onscreen{Run}.
@onscreen{Run}. Otherwise, the warning appears on every Otherwise, the warning appears on every interaction.}
interaction.}
@item{@PrefItem{Ask about clearing test coverage} --- If checked, @item{@PrefItem{Ask about clearing test coverage} --- If checked, when
when test coverage annotations are displayed DrRacket prompts test coverage annotations are displayed DrRacket prompts about
about removing them. This setting only applies to the PLT removing them. This setting only applies to the PLT languages.
languages. DrRacket never asks in the teaching languages.} DrRacket never asks in the teaching languages.}
@item{@PrefItem{Check for newer Racket versions} --- If @item{@PrefItem{Check for newer Racket versions} --- If checked,
checked, DrRacket periodically polls a server to determine DrRacket periodically polls a server to determine whether a newer
whether a newer version of DrRacket is available.} version of DrRacket is available.}
] ]
@section{@onscreen{General}} @section{@onscreen{General}}
@itemize[ @itemize[
@item{@PrefItem{Number of recent items} --- controls the @item{@PrefItem{Number of recent items} --- controls the length of the
length of the @onscreen{Open Recent} menu (in the @onscreen{File} @onscreen{Open Recent} menu (in the @onscreen{File} menu).}
menu).}
@item{@PrefItem{Auto-save files} --- If checked, the editor @item{@PrefItem{Auto-save files} --- If checked, the editor generates
generates autosave files (see @secref["drracket-autosave-files"]) autosave files (see @secref["drracket-autosave-files"]) for files
for files that have not been saved after five minutes.} that have not been saved after five minutes.}
@item{@PrefItem{Backup files} --- If checked, when saving a file for @item{@PrefItem{Backup files} --- If checked, when saving a file for the
the first time in each editing session, the original copy of the first time in each editing session, the original copy of the file
file is copied to a backup file in the same directory. The backup is copied to a backup file in the same directory. The backup
files have the same name as the original, except that they end in files have the same name as the original, except that they end in
either @indexed-file{.bak} or @indexed-file{~}.} either @indexed-file{.bak} or @indexed-file{~}.}
@ -164,61 +169,63 @@ The preferences dialog consists of several panels.
status line at the bottom of each window.} status line at the bottom of each window.}
@item{@PrefItem{Count column numbers from one} --- If checked, the @item{@PrefItem{Count column numbers from one} --- If checked, the
status line's column counter counts from one. Otherwise, it counts status line's column counter counts from one. Otherwise, it
from zero.} counts from zero.}
@item{@PrefItem{Display line numbers in buffer; not character @item{@PrefItem{Display line numbers in buffer; not character offsets}
offsets} --- If checked, the status line shows a --- If checked, the status line shows a
@nonterm{line}:@nonterm{column} display for the current selection @nonterm{line}:@nonterm{column} display for the current selection
rather than the character offset into the text.} rather than the character offset into the text.}
@item{@PrefItem{Automatically print to PostScript file} --- If @item{@PrefItem{Automatically print to PostScript file} --- If checked,
checked, printing will automatically save PostScript files. If printing will automatically save PostScript files. If not,
not, printing will use the standard printing mechanisms for your printing will use the standard printing mechanisms for your
computer.} computer.}
@item{@PrefItem{Open files in separate tabs (not separate windows)} @item{@PrefItem{Open files in separate tabs (not separate windows)} ---
-- If checked, DrRacket will use tabs in the front-most window to If checked, DrRacket will use tabs in the front-most window to
open new files, rather than creating new windows for new files.} open new files, rather than creating new windows for new files.}
@item{@PrefItem{Automatically open interactions window when running @item{@PrefItem{Automatically open interactions window when running a
a program} -- If checked, DrRacket shows the interactions window program} --- If checked, DrRacket shows the interactions window
(if it is hidden) when a program is run.} (if it is hidden) when a program is run.}
@item{@PrefItem{Automatically switch to the module language when opening a module} -- @item{@PrefItem{Automatically switch to the module language when opening
If checked, DrRacket will recognize files that have a @tt{#lang} line a module} --- If checked, DrRacket will recognize files that have
and adjust the language setting automatically.} a @tt{#lang} line and adjust the language setting automatically.}
@item{@PrefItem{Put the interactions window beside the definitions @item{@PrefItem{Put the interactions window beside the definitions
window} -- If checked, DrRacket puts the interactions window to the window} --- If checked, DrRacket puts the interactions window to
right of the definitions window. By default, the interactions the right of the definitions window. By default, the interactions
window is below the definitions window.} window is below the definitions window.}
@item{@PrefItem{Always show the #lang line in the Module language} -- @item{@PrefItem{Always show the #lang line in the Module language} ---
If checked, the module language always shows the @hash-lang[] If checked, the module language always shows the @hash-lang[] line
line (even when it would ordinarily be scrolled off of the page), assuming (even when it would ordinarily be scrolled off of the page),
that the @hash-lang[] line is the first line in the file. assuming that the @hash-lang[] line is the first line in the file.}
}
] ]
@section{@onscreen{Profiling}} @section{@onscreen{Profiling}}
This preference panel configures the profiling report. The band of This preference panel configures the profiling report. The band of
color shows the range of colors that profiled functions take color shows the range of colors that profiled functions take on. Colors
on. Colors near the right are used for code that is not invoked near the right are used for code that is not invoked often and colors on
often and colors on the right are used for code that is invoked the right are used for code that is invoked often.
often.
If you are interested in more detail at the low end, choose the If you are interested in more detail at the low end, choose the
@onscreen{Square root} check box. If you are interested in more @onscreen{Square root} check box. If you are interested in more detail
detail at the upper end, choose the @onscreen{Square} check box. at the upper end, choose the @onscreen{Square} check box.
@section{@onscreen{Browser}} @section{@onscreen{Browser}}
This preferences panel allows you to configure your HTTP This preferences panel allows you to configure your HTTP proxy. Contact
proxy. Contact your system administrator for details. your system administrator for details.
@section{@onscreen{Tools}} @section{@onscreen{Tools}}
This preference panel allows you to configure the currently active plugins. This preference panel allows you to configure the currently active
plugins.

12
collects/scribblings/framework/editor.scrbl
View File

@ -25,7 +25,7 @@
for more info about edit sequences. for more info about edit sequences.
} }
@defmethod*[(((run-after-edit-sequence (thunk (-> void)) (tag (union symbol? |#f|) |#f|)) void))]{ @defmethod*[(((run-after-edit-sequence (thunk (-> void)) (tag (union symbol? #f) #f)) void))]{
This method is used to install callbacks that will be run after any This method is used to install callbacks that will be run after any
edit-sequence completes. edit-sequence completes.
@ -40,7 +40,7 @@
@method[editor:basic<%> run-after-edit-sequence]'s argument will be called. @method[editor:basic<%> run-after-edit-sequence]'s argument will be called.
} }
@defmethod*[(((get-top-level-window) (union |#f| (is-a?/c top-level-window<%>))))]{ @defmethod*[(((get-top-level-window) (union #f (is-a?/c top-level-window<%>))))]{
Returns the Returns the
@scheme[top-level-window<%>] @scheme[top-level-window<%>]
currently associated with this buffer. currently associated with this buffer.
@ -53,7 +53,7 @@
Returns @scheme[#t] if the file on disk has been modified, by some other program. Returns @scheme[#t] if the file on disk has been modified, by some other program.
} }
@defmethod*[(((save-file/gui-error (filename (union path |#f|) |#f|) (format (union (quote guess) (quote standard) (quote text) (quote text-force-cr) same copy) (quote same)) (show-errors? boolean |#t|)) boolean?))]{ @defmethod*[(((save-file/gui-error (filename (union path #f) #f) (format (union (quote guess) (quote standard) (quote text) (quote text-force-cr) same copy) (quote same)) (show-errors? boolean |#t|)) boolean?))]{
This method is an alternative to This method is an alternative to
@method[editor<%> save-file]. Rather than showing errors via the original stdout, it @method[editor<%> save-file]. Rather than showing errors via the original stdout, it
opens a dialog with an error message showing the error. opens a dialog with an error message showing the error.
@ -63,7 +63,7 @@
no error occurred and @scheme[#f] if an error occurred. no error occurred and @scheme[#f] if an error occurred.
} }
@defmethod*[(((load-file/gui-error (filename (union string |#f|) |#f|) (format (union (quote guess) (quote standard) (quote text) (quote text-force-cr) (quote same) (quote copy)) (quote guess)) (show-errors? boolean |#t|)) boolean?))]{ @defmethod*[(((load-file/gui-error (filename (union string #f) #f) (format (union (quote guess) (quote standard) (quote text) (quote text-force-cr) (quote same) (quote copy)) (quote guess)) (show-errors? boolean |#t|)) boolean?))]{
This method is an alternative to This method is an alternative to
@method[editor<%> load-file]. Rather than showing errors via the original stdout, it @method[editor<%> load-file]. Rather than showing errors via the original stdout, it
opens a dialog with an error message showing the error. opens a dialog with an error message showing the error.
@ -347,7 +347,7 @@
The class that this mixin produces uses the same initialization The class that this mixin produces uses the same initialization
arguments as its input. arguments as its input.
@defmethod*[#:mode override (((set-filename (name string) (temp? boolean |#f|)) void))]{ @defmethod*[#:mode override (((set-filename (name string) (temp? boolean #f)) void))]{
Updates the filename on each frame displaying this editor, for each Updates the filename on each frame displaying this editor, for each
frame that matches frame that matches
@ -399,7 +399,7 @@
Returns @scheme[#t]. Returns @scheme[#t].
} }
@defmethod*[(((do-autosave) (union |#f| string)))]{ @defmethod*[(((do-autosave) (union #f string)))]{
This method is called to perform the autosaving. This method is called to perform the autosaving.
See also See also
@scheme[autosave:register] @scheme[autosave:register]

267
collects/scribblings/framework/scheme.scrbl
View File

@ -7,272 +7,251 @@
@definterface[scheme:sexp-snip<%> ()]{ @definterface[scheme:sexp-snip<%> ()]{
@defmethod*[(((get-saved-snips) (listof snip%)))]{ @defmethod*[(((get-saved-snips) (listof snip%)))]{
This returns the list of snips hidden by the sexp snip. This returns the list of snips hidden by the sexp snip.
} }
} }
@defclass[scheme:sexp-snip% snip% (scheme:sexp-snip<%> readable-snip<%>)]{ @defclass[scheme:sexp-snip% snip% (scheme:sexp-snip<%> readable-snip<%>)]{
@defmethod*[#:mode override
@defmethod*[#:mode override (((get-text (offset number) (num number) (flattened? boolean |#f|)) string))]{ (((get-text (offset number) (num number)
(flattened? boolean #f))
Returns the concatenation of the text for all of the hidden string))]{
snips. Returns the concatenation of the text for all of the hidden snips.
} }
@defmethod*[#:mode override (((copy) (is-a?/c scheme:sexp-snip%)))]{ @defmethod*[#:mode override (((copy) (is-a?/c scheme:sexp-snip%)))]{
Returns a copy of this snip that includes the hidden snips. Returns a copy of this snip that includes the hidden snips.
} }
@defmethod*[#:mode override (((write (stream-out editor-stream-out%)) void))]{ @defmethod*[#:mode override (((write (stream-out editor-stream-out%)) void))]{
Saves the embedded snips Saves the embedded snips
} }
@defmethod*[#:mode override (((draw (dc dc<%>) (x real) (y real) (left real) (top real) (right real) (bottom real) (dx real) (dy real) (draw-caret symbol?)) void))]{ @defmethod*[#:mode override
(((draw (dc dc<%>) (x real) (y real)
(left real) (top real) (right real) (bottom real)
(dx real) (dy real) (draw-caret symbol?))
void))]{
Draws brackets with a centered ellipses between them. Draws brackets with a centered ellipses between them.
} }
@defmethod*[#:mode override (((get-extent (dc (is-a?/c dc<%>)) (x real) (y real) (w boxed |#f|) (h boxed |#f|) (descent boxed |#f|) (space boxed |#f|) (lspace boxed |#f|) (rspace boxed |#f|)) void))]{ @defmethod*[#:mode override
(((get-extent (dc (is-a?/c dc<%>)) (x real) (y real)
(w boxed #f) (h boxed #f)
(descent boxed #f) (space boxed #f)
(lspace boxed #f) (rspace boxed #f))
void))]{
Returns a size corresponding to what this snip draws. Returns a size corresponding to what this snip draws.
} }
} }
@definterface[scheme:text<%> (text:basic<%> mode:host-text<%> color:text<%>)]{ @definterface[scheme:text<%> (text:basic<%> mode:host-text<%> color:text<%>)]{
Texts matching this interface support Racket mode operations. Texts matching this interface support Racket mode operations.
@defmethod*[(((get-limit (start exact-integer)) int))]{ @defmethod*[(((get-limit (start exact-integer)) int))]{
Returns a limit for backward-matching parenthesis starting at
Returns a limit for backward-matching parenthesis starting at position position @scheme[start].
@scheme[start].
} }
@defmethod*[(((balance-parens (key-event (instance key-event%))) void))]{ @defmethod*[(((balance-parens (key-event (instance key-event%))) void))]{
This function is called when the user types a close parenthesis in the This function is called when the user types a close parenthesis in
@scheme[text%]. If the close parenthesis that the user inserted does not match the the @scheme[text%]. If the close parenthesis that the user inserted
corresponding open parenthesis and the @scheme['framework:fixup-parens] preference is does not match the corresponding open parenthesis and the
@scheme[#t] (see @scheme['framework:fixup-parens] preference is @scheme[#t] (see
@scheme[preferences:get]) the correct closing parenthesis is inserted. @scheme[preferences:get]) the correct closing parenthesis is
If the @scheme['framework:paren-match] preference is inserted. If the @scheme['framework:paren-match] preference is
@scheme[#t] (see @scheme[#t] (see @scheme[preferences:get]) the matching open
@scheme[preferences:get]) the matching open parenthesis is flashed. parenthesis is flashed.
} }
@defmethod*[(((tabify-on-return?) boolean?))]{ @defmethod*[(((tabify-on-return?) boolean?))]{
The result of this method is used to determine if the return key The result of this method is used to determine if the return key
automatically tabs over to the correct position. automatically tabs over to the correct position.
Override it to change its behavior. Override it to change its behavior.
} }
@defmethod*[(((tabify (start-pos exact-integer (send this text get-start-position))) void))]{ @defmethod*[(((tabify (start-pos exact-integer
(send this text get-start-position)))
void))]{
Tabs the line containing by @scheme[start-pos] Tabs the line containing by @scheme[start-pos]
} }
@defmethod*[(((tabify-selection (start exact-integer) (end exact-integer)) void))]{ @defmethod*[(((tabify-selection (start exact-integer) (end exact-integer))
void))]{
Sets the tabbing for the lines containing positions @scheme[start] Sets the tabbing for the lines containing positions @scheme[start]
through @scheme[end]. through @scheme[end].
} }
@defmethod*[(((tabify-all) void))]{ @defmethod*[(((tabify-all) void))]{
Tabs all lines. Tabs all lines.
} }
@defmethod*[(((insert-return) void))]{ @defmethod*[(((insert-return) void))]{
Inserts a newline into the buffer. If Inserts a newline into the buffer. If
@method[scheme:text<%> tabify-on-return?] @method[scheme:text<%> tabify-on-return?] returns @scheme[#t], this
returns @scheme[#t], this will tabify the new line. will tabify the new line.
} }
@defmethod*[(((box-comment-out-selection (start-pos (or/c (symbols 'start) exact-integer?)) (end-pos (or/c (symbols 'end) exact-integer?))) void))]{ @defmethod*[(((box-comment-out-selection
This method comments out a selection in the text by putting it into a comment box. (start-pos (or/c (symbols 'start) exact-integer?))
(end-pos (or/c (symbols 'end) exact-integer?)))
void))]{
This method comments out a selection in the text by putting it into
a comment box.
Removes the region from @scheme[start-pos] to @scheme[end-pos] from
the editor and inserts a comment box with that region of text
inserted into the box.
Removes the region from @scheme[start-pos] to @scheme[end-pos] If @scheme[start-pos] is @scheme['start], the starting point of the
from the editor and inserts a comment box with that region selection is used. If @scheme[end-pos] is @scheme['end], the ending
of text inserted into the box. point of the selection is used.
If @scheme[start-pos] is @scheme['start], the starting point of
the selection is used. If @scheme[end-pos] is @scheme['end],
the ending point of the selection is used.
} }
@defmethod*[(((comment-out-selection (start exact-integer) (end exact-integer)) void))]{ @defmethod*[(((comment-out-selection (start exact-integer)
(end exact-integer))
Comments the lines containing positions @scheme[start] through @scheme[end] void))]{
by inserting a semi-colon at the front of each line. Comments the lines containing positions @scheme[start] through
@scheme[end] by inserting a semi-colon at the front of each line.
} }
@defmethod*[(((uncomment-selection (start int) (end int)) void))]{ @defmethod*[(((uncomment-selection (start int) (end int)) void))]{
Uncomments the lines containing positions @scheme[start] through
Uncomments the lines containing positions @scheme[start] through @scheme[end]. @scheme[end].
} }
@defmethod*[(((get-forward-sexp (start exact-integer)) (union |#f| exact-integer)))]{ @defmethod*[(((get-forward-sexp (start exact-integer))
(union #f exact-integer)))]{
Returns the position of the end of next S-expression after position Returns the position of the end of next S-expression after position
@scheme[start], or @scheme[#f] if there is no appropriate answer. @scheme[start], or @scheme[#f] if there is no appropriate answer.
} }
@defmethod*[(((remove-sexp (start exact-integer)) void))]{ @defmethod*[(((remove-sexp (start exact-integer)) void))]{
Forward-deletes the S-expression starting after the position
Forward-deletes the S-expression starting after the position @scheme[start]. @scheme[start].
} }
@defmethod*[(((forward-sexp (start |#t|)) exact-integer))]{ @defmethod*[(((forward-sexp (start |#t|)) exact-integer))]{
Moves forward over the S-expression starting at position
Moves forward over the S-expression starting at position @scheme[start]. @scheme[start].
} }
@defmethod*[(((flash-forward-sexp (start-pos exact-integer)) void))]{ @defmethod*[(((flash-forward-sexp (start-pos exact-integer)) void))]{
Flashes the parenthesis that closes the sexpression at Flashes the parenthesis that closes the sexpression at
@scheme[start-pos]. @scheme[start-pos].
} }
@defmethod*[(((get-backward-sexp (start exact-integer)) (union exact-integer |#f|)))]{ @defmethod*[(((get-backward-sexp (start exact-integer))
(union exact-integer #f)))]{
Returns the position of the start of the S-expression before or Returns the position of the start of the S-expression before or
containing @scheme[start], or @scheme[#f] if there is no appropriate containing @scheme[start], or @scheme[#f] if there is no appropriate
answer. answer.
} }
@defmethod*[(((flash-backward-sexp (start-pos exact-integer)) void))]{ @defmethod*[(((flash-backward-sexp (start-pos exact-integer)) void))]{
Flashes the parenthesis that opens the sexpression at Flashes the parenthesis that opens the sexpression at
@scheme[start-pos]. @scheme[start-pos].
} }
@defmethod*[(((backward-sexp (start-pos exact-integer)) void))]{ @defmethod*[(((backward-sexp (start-pos exact-integer)) void))]{
Move the caret backwards one sexpression Move the caret backwards one sexpression
Moves the caret to the beginning of the sexpression that ends at Moves the caret to the beginning of the sexpression that ends at
@scheme[start-pos]. @scheme[start-pos].
} }
@defmethod*[(((find-up-sexp (start-pos exact-integer)) (union |#f| exact-integer)))]{ @defmethod*[(((find-up-sexp (start-pos exact-integer))
(union #f exact-integer)))]{
Returns the position of the beginning of the next sexpression outside Returns the position of the beginning of the next sexpression
the sexpression that contains @scheme[start-pos]. If there is no such outside the sexpression that contains @scheme[start-pos]. If there
sexpression, it returns @scheme[#f]. is no such sexpression, it returns @scheme[#f].
} }
@defmethod*[(((up-sexp (start exact-integer)) void))]{ @defmethod*[(((up-sexp (start exact-integer)) void))]{
Moves backward out of the S-expression containing the position
Moves backward out of the S-expression containing the position @scheme[start]. @scheme[start].
} }
@defmethod*[(((find-down-sexp (start-pos exact-integer)) (union |#f| exact-integer)))]{ @defmethod*[(((find-down-sexp (start-pos exact-integer))
(union #f exact-integer)))]{
Returns the position of the beginning of the next sexpression inside Returns the position of the beginning of the next sexpression inside
the sexpression that contains @scheme[start-pos]. If there is no such the sexpression that contains @scheme[start-pos]. If there is no
sexpression, it returns @scheme[#f]. such sexpression, it returns @scheme[#f].
} }
@defmethod*[(((down-sexp (start exact-integer)) void))]{ @defmethod*[(((down-sexp (start exact-integer)) void))]{
Moves forward into the next S-expression after the position
Moves forward into the next S-expression after the position @scheme[start]. @scheme[start].
} }
@defmethod*[(((remove-parens-forward (start exact-integer)) void))]{ @defmethod*[(((remove-parens-forward (start exact-integer)) void))]{
Removes the parentheses from the S-expression starting after the Removes the parentheses from the S-expression starting after the
position @scheme[start]. position @scheme[start].
} }
@defmethod*[(((select-forward-sexp (start exact-integer)) |#t|))]{ @defmethod*[(((select-forward-sexp (start exact-integer)) |#t|))]{
Selects the next S-expression, starting at position @scheme[start]. Selects the next S-expression, starting at position @scheme[start].
} }
@defmethod*[(((select-backward-sexp (start exact-integer)) |#t|))]{ @defmethod*[(((select-backward-sexp (start exact-integer)) |#t|))]{
Selects the previous S-expression, starting at position
Selects the previous S-expression, starting at position @scheme[start]. @scheme[start].
} }
@defmethod*[(((select-up-sexp (start exact-integer)) |#t|))]{ @defmethod*[(((select-up-sexp (start exact-integer)) |#t|))]{
Selects the region to the enclosing S-expression, starting at
Selects the region to the enclosing S-expression, starting at position @scheme[start]. position @scheme[start].
} }
@defmethod*[(((select-down-sexp (start exact-integer)) |#t|))]{ @defmethod*[(((select-down-sexp (start exact-integer)) |#t|))]{
Selects the region to the next contained S-expression, starting at
Selects the region to the next contained S-expression, starting at position @scheme[start]. position @scheme[start].
} }
@defmethod*[(((transpose-sexp (start exact-integer)) void))]{ @defmethod*[(((transpose-sexp (start exact-integer)) void))]{
Swaps the S-expression beginning before the position @scheme[start]
Swaps the S-expression beginning before the position @scheme[start] with with the next S-expression following @scheme[start].
the next S-expression following @scheme[start].
} }
@defmethod*[(((mark-matching-parenthesis (pos exact-positive-integer)) void))]{ @defmethod*[(((mark-matching-parenthesis (pos exact-positive-integer))
If the paren after @scheme[pos] is matched, this method void))]{
highlights it and its matching counterpart in dark green. If the paren after @scheme[pos] is matched, this method highlights
it and its matching counterpart in dark green.
} }
@defmethod*[(((get-tab-size) exact-integer))]{ @defmethod*[(((get-tab-size) exact-integer))]{
This method returns the current size of the tabs for scheme mode. This method returns the current size of the tabs for scheme mode.
See also See also @method[scheme:text<%> set-tab-size].
@method[scheme:text<%> set-tab-size].
} }
@defmethod*[(((set-tab-size (new-size exact-integer)) void))]{ @defmethod*[(((set-tab-size (new-size exact-integer)) void))]{
This method sets the tab size for this This method sets the tab size for this text.
text.
} }
@defmethod*[(((introduce-let-ans) void))]{ @defmethod*[(((introduce-let-ans) void))]{
Adds a let around the current s-expression and a printf into the body Adds a let around the current s-expression and a printf into the
of the let. body of the let.
} }
@defmethod*[(((move-sexp-out) void))]{ @defmethod*[(((move-sexp-out) void))]{
Replaces the sexpression surrounding the insertion point with the Replaces the sexpression surrounding the insertion point with the
sexpression following the insertion point. sexpression following the insertion point.
} }
} }
@defmixin[scheme:text-mixin (text:basic<%> mode:host-text<%> color:text<%> text:autocomplete<%>) (scheme:text<%>)]{ @defmixin[scheme:text-mixin
(text:basic<%> mode:host-text<%> color:text<%> text:autocomplete<%>)
(scheme:text<%>)]{
This mixin adds functionality for editing Racket files. This mixin adds functionality for editing Racket files.
The result of this mixin uses the same initialization arguments as the The result of this mixin uses the same initialization arguments as the
mixin's argument. mixin's argument.
@defmethod*[#:mode override (((get-word-at (pos positive-exact-integer)) string))]{
Returns the word just before @scheme[pos], which is then used
as the prefix for auto-completion.
@defmethod*[#:mode override
(((get-word-at (pos positive-exact-integer)) string))]{
Returns the word just before @scheme[pos], which is then used as the
prefix for auto-completion.
} }
@defmethod[#:mode override (get-start-of-line [pos exact-nonnegative-integer?]) exact-nonnegative-integer?]{ @defmethod[#:mode override
Returns the first non-whitespace character in the paragraph containing @racket[pos], (get-start-of-line [pos exact-nonnegative-integer?])
unless the position is already there, in which case it returns the first position of the paragraph. exact-nonnegative-integer?]{
Returns the first non-whitespace character in the paragraph
containing @racket[pos], unless the position is already there, in
which case it returns the first position of the paragraph.
} }
} }
@definterface[scheme:text-mode<%> ()]{ @definterface[scheme:text-mode<%> ()]{
The result of The result of @scheme[scheme:text-mode-mixin] implements this
@scheme[scheme:text-mode-mixin] interface.
implements this interface.
} }
@defmixin[scheme:text-mode-mixin (color:text-mode<%> mode:surrogate-text<%>) (scheme:text-mode<%>)]{ @defmixin[scheme:text-mode-mixin
This mixin adds Racket mode functionality (color:text-mode<%> mode:surrogate-text<%>)
to the mode that it is mixed into. The resulting (scheme:text-mode<%>)]{
mode assumes that it is only set to an editor This mixin adds Racket mode functionality to the mode that it is mixed
that is the result of into. The resulting mode assumes that it is only set to an editor
@scheme[scheme:text-mixin]. that is the result of @scheme[scheme:text-mixin].
@defmethod*[#:mode override (((on-disable-surrogate) void))]{
Removes the scheme keymap (see also @defmethod*[#:mode override (((on-disable-surrogate) void))]{
@scheme[scheme:get-keymap]) and disables any parenthesis Removes the scheme keymap (see also @scheme[scheme:get-keymap]) and
highlighting in the host editor. disables any parenthesis highlighting in the host editor.
} }
@defmethod*[#:mode override (((on-enable-surrogate) void))]{ @defmethod*[#:mode override (((on-enable-surrogate) void))]{
Adds the scheme keymap (see also @scheme[scheme:get-keymap]) and
Adds the scheme keymap (see also enables a parenthesis highlighting in the host editor.
@scheme[scheme:get-keymap]) and enables a parenthesis
highlighting in the host editor.
} }
} }
@defmixin[scheme:set-mode-mixin (scheme:text<%> mode:host-text<%>) ()]{ @defmixin[scheme:set-mode-mixin (scheme:text<%> mode:host-text<%>) ()]{
This mixin creates a new instance of This mixin creates a new instance of @scheme[scheme:text-mode%] and
@scheme[scheme:text-mode%] installs it, by calling its own @method[mode:host-text<%>
and installs it, by calling its own set-surrogate] method with the object.
@method[mode:host-text<%> set-surrogate]
method with the object.
} }
@defclass[scheme:text% (scheme:set-mode-mixin (scheme:text-mixin (text:autocomplete-mixin (mode:host-text-mixin color:text%)))) ()]{} @defclass[scheme:text%
(scheme:set-mode-mixin
(scheme:text-mixin
(text:autocomplete-mixin (mode:host-text-mixin color:text%))))
()]{}
@defclass[scheme:text-mode% (scheme:text-mode-mixin color:text-mode%) ()]{} @defclass[scheme:text-mode% (scheme:text-mode-mixin color:text-mode%) ()]{}
@(include-previously-extracted "main-extracts.ss" #rx"^scheme:") @(include-previously-extracted "main-extracts.ss" #rx"^scheme:")

20
collects/scribblings/framework/text.scrbl
View File

@ -107,7 +107,7 @@
moved. A snip may refuse to be moved by returning @scheme[#f] from moved. A snip may refuse to be moved by returning @scheme[#f] from
@method[snip% release-from-owner]. @method[snip% release-from-owner].
} }
@defmethod*[(((initial-autowrap-bitmap) (union |#f| (instance bitmap%))))]{ @defmethod*[(((initial-autowrap-bitmap) (union #f (instance bitmap%))))]{
The result of this method is used as the initial autowrap The result of this method is used as the initial autowrap
bitmap. Override this method to change the initial bitmap. Override this method to change the initial
@scheme[bitmap%]. See also @scheme[bitmap%]. See also
@ -488,13 +488,13 @@
The contents of the two The contents of the two
editor are kept in sync, as modifications editor are kept in sync, as modifications
to this object happen. to this object happen.
@defmethod*[(((get-delegate) (union |#f| (instanceof text%))))]{ @defmethod*[(((get-delegate) (union #f (instanceof text%))))]{
The result of this method is the @scheme[text%] object The result of this method is the @scheme[text%] object
that the contents of this editor are being delegated to, or that the contents of this editor are being delegated to, or
@scheme[#f], if there is none. @scheme[#f], if there is none.
} }
@defmethod*[(((set-delegate (delegate (union |#f| (instanceof text%)))) void))]{ @defmethod*[(((set-delegate (delegate (union #f (instanceof text%)))) void))]{
This method sets the current delegate. This method sets the current delegate.
@ -531,7 +531,17 @@
Creates and returns an instance of Creates and returns an instance of
@scheme[text:1-pixel-string-snip%]. @scheme[text:1-pixel-string-snip%].
} }
@defmethod*[#:mode override (((get-extent (dc (instanceof dc<%>)) (x real) (y real) (w (box (union non-negative-real-number |#f|)) |#f|) (h (box (union non-negative-real-number |#f|)) |#f|) (descent (box (union non-negative-real-number |#f|)) |#f|) (space (box (union non-negative-real-number |#f|)) |#f|) (lspace (box (union non-negative-real-number |#f|)) |#f|) (rspace (box (union non-negative-real-number |#f|)) |#f|)) void))]{ @defmethod*[#:mode override
(((get-extent
(dc (instanceof dc<%>))
(x real) (y real)
(w (box (union non-negative-real-number #f)) #f)
(h (box (union non-negative-real-number #f)) #f)
(descent (box (union non-negative-real-number #f)) #f)
(space (box (union non-negative-real-number #f)) #f)
(lspace (box (union non-negative-real-number #f)) #f)
(rspace (box (union non-negative-real-number #f)) #f))
void))]{
Sets the descent, space, lspace, and rspace to zero. Sets Sets the descent, space, lspace, and rspace to zero. Sets
the height to 1. Sets the width to the number of characters the height to 1. Sets the width to the number of characters
@ -573,7 +583,7 @@
Creates and returns an instance of Creates and returns an instance of
@scheme[text:1-pixel-tab-snip%]. @scheme[text:1-pixel-tab-snip%].
} }
@defmethod*[#:mode override (((get-extent (dc (instanceof dc<%>)) (x real) (y real) (w (box (union non-negative-real-number |#f|)) |#f|) (h (box (union non-negative-real-number |#f|)) |#f|) (descent (box (union non-negative-real-number |#f|)) |#f|) (space (box (union non-negative-real-number |#f|)) |#f|) (lspace (box (union non-negative-real-number |#f|)) |#f|) (rspace (box (union non-negative-real-number |#f|)) |#f|)) void))]{ @defmethod*[#:mode override (((get-extent (dc (instanceof dc<%>)) (x real) (y real) (w (box (union non-negative-real-number #f)) #f) (h (box (union non-negative-real-number #f)) #f) (descent (box (union non-negative-real-number #f)) #f) (space (box (union non-negative-real-number #f)) #f) (lspace (box (union non-negative-real-number #f)) #f) (rspace (box (union non-negative-real-number #f)) #f)) void))]{
Sets the descent, space, lspace, and rspace to zero. Sets Sets the descent, space, lspace, and rspace to zero. Sets
the height to 1. Sets the width to the width of tabs as the height to 1. Sets the width to the width of tabs as

357
collects/scribblings/raco/zo-parse.scrbl
View File

@ -12,10 +12,10 @@
@defmodule[compiler/zo-parse] @defmodule[compiler/zo-parse]
@defproc[(zo-parse [in input-port? (current-input-port)]) compilation-top?]{ @defproc[(zo-parse [in input-port? (current-input-port)]) compilation-top?]{
Parses a port (typically the result of opening a @filepath{.zo} file) Parses a port (typically the result of opening a @filepath{.zo} file)
containing bytecode. Beware that the structure types used to represent the containing bytecode. Beware that the structure types used to
bytecode are subject to frequent changes across Racket versons. represent the bytecode are subject to frequent changes across Racket
versons.
The parsed bytecode is returned in a @racket[compilation-top] The parsed bytecode is returned in a @racket[compilation-top]
structure. For a compiled module, the @racket[compilation-top] structure. For a compiled module, the @racket[compilation-top]
@ -37,21 +37,21 @@ stack. For example, execution of an @racket[application] structure
reserves space on the stack for each argument result. Similarly, when reserves space on the stack for each argument result. Similarly, when
a @racket[let-one] structure (for a simple @racket[let]) is executed, a @racket[let-one] structure (for a simple @racket[let]) is executed,
the value obtained by evaluating the right-hand side expression is the value obtained by evaluating the right-hand side expression is
pushed onto the stack, and then the body is evaluated. Local variables pushed onto the stack, and then the body is evaluated. Local
are always accessed as offsets from the current stack position. When a variables are always accessed as offsets from the current stack
function is called, its arguments are passed on the stack. A closure position. When a function is called, its arguments are passed on the
is created by transferring values from the stack to a flat closure stack. A closure is created by transferring values from the stack to
record, and when a closure is applied, the saved values are restored a flat closure record, and when a closure is applied, the saved values
on the stack (though possibly in a different order and likely in a are restored on the stack (though possibly in a different order and
more compact layout than when they were captured). likely in a more compact layout than when they were captured).
When a sub-expression produces a value, then the stack pointer is When a sub-expression produces a value, then the stack pointer is
restored to its location from before evaluating the restored to its location from before evaluating the sub-expression.
sub-expression. For example, evaluating the right-hand size for a For example, evaluating the right-hand size for a @racket[let-one]
@racket[let-one] structure may temporarily push values onto the stack, structure may temporarily push values onto the stack, but the stack is
but the stack is restored to its pre-@racket[let-one] position before restored to its pre-@racket[let-one] position before pushing the
pushing the resulting value and continuing with the body. In addition, resulting value and continuing with the body. In addition, a tail
a tail call resets the stack pointer to the position that follows the call resets the stack pointer to the position that follows the
enclosing function's arguments, and then the tail call continues by enclosing function's arguments, and then the tail call continues by
pushing onto the stack the arguments for the tail-called function. pushing onto the stack the arguments for the tail-called function.
@ -77,23 +77,23 @@ the stack) before evaluating expressions that might use them.}
@defstruct+[zo ()]{ @defstruct+[zo ()]{
A supertype for all zo objects that can appear in compiled code.} A supertype for all zo objects that can appear in compiled code.}
@defstruct+[(compilation-top zo) ([max-let-depth exact-nonnegative-integer?] @defstruct+[(compilation-top zo)
([max-let-depth exact-nonnegative-integer?]
[prefix prefix?] [prefix prefix?]
[code (or/c form? any/c)])]{ [code (or/c form? any/c)])]{
Wraps compiled code. The @racket[max-let-depth] field indicates the Wraps compiled code. The @racket[max-let-depth] field indicates the
maximum stack depth that @racket[code] creates (not counting the maximum stack depth that @racket[code] creates (not counting the
@racket[prefix] array). The @racket[prefix] field describes top-level @racket[prefix] array). The @racket[prefix] field describes top-level
variables, module-level variables, and quoted syntax-objects accessed variables, module-level variables, and quoted syntax-objects accessed
by @racket[code]. The @racket[code] field contains executable code; it by @racket[code]. The @racket[code] field contains executable code;
is normally a @racket[form], but a literal value is represented as it is normally a @racket[form], but a literal value is represented as
itself.} itself.}
@defstruct+[(prefix zo)
@defstruct+[(prefix zo) ([num-lifts exact-nonnegative-integer?] ([num-lifts exact-nonnegative-integer?]
[toplevels (listof (or/c #f symbol? global-bucket? module-variable?))] [toplevels (listof (or/c #f symbol? global-bucket?
module-variable?))]
[stxs (listof stx?)])]{ [stxs (listof stx?)])]{
Represents a ``prefix'' that is pushed onto the stack to initiate Represents a ``prefix'' that is pushed onto the stack to initiate
evaluation. The prefix is an array, where buckets holding the values evaluation. The prefix is an array, where buckets holding the values
for @racket[toplevels] are first, then a bucket for another array if for @racket[toplevels] are first, then a bucket for another array if
@ -101,38 +101,29 @@ for @racket[toplevels] are first, then a bucket for another array if
lifted local procedures. lifted local procedures.
In @racket[toplevels], each element is one of the following: In @racket[toplevels], each element is one of the following:
@itemize[ @itemize[
@item{a @racket[#f], which indicates a dummy variable that is used
@item{a @racket[#f], which indicates a dummy variable that is used to to access the enclosing module/namespace at run time;}
access the enclosing module/namespace at run time;}
@item{a symbol, which is a reference to a variable defined in the @item{a symbol, which is a reference to a variable defined in the
enclosing module;} enclosing module;}
@item{a @racket[global-bucket], which is a top-level variable (appears
@item{a @racket[global-bucket], which is a top-level variable only outside of modules); or}
(appears only outside of modules); or}
@item{a @racket[module-variable], which indicates a variable imported @item{a @racket[module-variable], which indicates a variable imported
from another module.} from another module.}
] ]
The variable buckets and syntax objects that are recorded in a prefix The variable buckets and syntax objects that are recorded in a prefix
are accessed by @racket[toplevel] and @racket[topsyntax] expression are accessed by @racket[toplevel] and @racket[topsyntax] expression
forms.} forms.}
@defstruct+[(global-bucket zo) ([name symbol?])]{ @defstruct+[(global-bucket zo) ([name symbol?])]{
Represents a top-level variable, and used only in a @racket[prefix].} Represents a top-level variable, and used only in a @racket[prefix].}
@defstruct+[(module-variable zo)
@defstruct+[(module-variable zo) ([modidx module-path-index?] ([modidx module-path-index?]
[sym symbol?] [sym symbol?]
[pos exact-integer?] [pos exact-integer?]
[phase (or/c 0 1)])]{ [phase (or/c 0 1)])]{
Represents a top-level variable, and used only in a @racket[prefix]. Represents a top-level variable, and used only in a @racket[prefix].
The @racket[pos] may record the variable's offset within its module, The @racket[pos] may record the variable's offset within its module,
or it can be @racket[-1] if the variable is always located by name. or it can be @racket[-1] if the variable is always located by name.
@ -141,7 +132,6 @@ its module.}
@defstruct+[(stx zo) ([encoded wrapped?])]{ @defstruct+[(stx zo) ([encoded wrapped?])]{
Wraps a syntax object in a @racket[prefix].} Wraps a syntax object in a @racket[prefix].}
@ -149,17 +139,16 @@ Wraps a syntax object in a @racket[prefix].}
@section{Forms} @section{Forms}
@defstruct+[(form zo) ()]{ @defstruct+[(form zo) ()]{
A supertype for all forms that can appear in compiled code (including A supertype for all forms that can appear in compiled code (including
@racket[expr]s), except for literals that are represented as @racket[expr]s), except for literals that are represented as
themselves.} themselves.}
@defstruct+[(def-values form) ([ids (listof toplevel?)] @defstruct+[(def-values form)
([ids (listof toplevel?)]
[rhs (or/c expr? seq? any/c)])]{ [rhs (or/c expr? seq? any/c)])]{
Represents a @racket[define-values] form. Each element of
Represents a @racket[define-values] form. Each element of @racket[ids] @racket[ids] will reference via the prefix either a top-level variable
will reference via the prefix either a top-level variable or a local or a local module variable.
module variable.
After @racket[rhs] is evaluated, the stack is restored to its depth After @racket[rhs] is evaluated, the stack is restored to its depth
from before evaluating @racket[rhs].} from before evaluating @racket[rhs].}
@ -169,31 +158,28 @@ from before evaluating @racket[rhs].}
[rhs (or/c expr? seq? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])] [max-let-depth exact-nonnegative-integer?])]
@defstruct+[(def-for-syntax form) ([ids (listof toplevel?)] @defstruct+[(def-for-syntax form)
([ids (listof toplevel?)]
[rhs (or/c expr? seq? any/c)] [rhs (or/c expr? seq? any/c)]
[prefix prefix?] [prefix prefix?]
[max-let-depth exact-nonnegative-integer?])] [max-let-depth exact-nonnegative-integer?])]
)]{ )]{
Represents a @racket[define-syntaxes] or Represents a @racket[define-syntaxes] or
@racket[define-values-for-syntax] form. The @racket[rhs] expression @racket[define-values-for-syntax] form. The @racket[rhs] expression
has its own @racket[prefix], which is pushed before evaluating has its own @racket[prefix], which is pushed before evaluating
@racket[rhs]; the stack is restored after obtaining the result @racket[rhs]; the stack is restored after obtaining the result values.
values. The @racket[max-let-depth] field indicates the maximum size of The @racket[max-let-depth] field indicates the maximum size of the
the stack that will be created by @racket[rhs] (not counting stack that will be created by @racket[rhs] (not counting
@racket[prefix]).} @racket[prefix]).}
@defstruct+[(req form) ([reqs stx?] @defstruct+[(req form) ([reqs stx?]
[dummy toplevel?])]{ [dummy toplevel?])]{
Represents a top-level @racket[#%require] form (but not one in a Represents a top-level @racket[#%require] form (but not one in a
@racket[module] form) with a sequence of specifications @racket[module] form) with a sequence of specifications @racket[reqs].
@racket[reqs]. The @racket[dummy] variable is used to access to the The @racket[dummy] variable is used to access to the top-level
top-level namespace.} namespace.}
@defstruct+[(seq form) ([forms (listof (or/c form? any/c))])]{ @defstruct+[(seq form) ([forms (listof (or/c form? any/c))])]{
Represents a @racket[begin] form, either as an expression or at the Represents a @racket[begin] form, either as an expression or at the
top level (though the latter is more commonly a @racket[splice] form). top level (though the latter is more commonly a @racket[splice] form).
When a @racket[seq] appears in an expression position, its When a @racket[seq] appears in an expression position, its
@ -202,17 +188,15 @@ When a @racket[seq] appears in an expression position, its
After each form in @racket[forms] is evaluated, the stack is restored After each form in @racket[forms] is evaluated, the stack is restored
to its depth from before evaluating the form.} to its depth from before evaluating the form.}
@defstruct+[(splice form) ([forms (listof (or/c form? any/c))])]{ @defstruct+[(splice form) ([forms (listof (or/c form? any/c))])]{
Represents a top-level @racket[begin] form where each evaluation is Represents a top-level @racket[begin] form where each evaluation is
wrapped with a continuation prompt. wrapped with a continuation prompt.
After each form in @racket[forms] is evaluated, the stack is restored After each form in @racket[forms] is evaluated, the stack is restored
to its depth from before evaluating the form.} to its depth from before evaluating the form.}
@defstruct+[(mod form)
@defstruct+[(mod form) ([name symbol?] ([name symbol?]
[srcname symbol?] [srcname symbol?]
[self-modidx module-path-index?] [self-modidx module-path-index?]
[prefix prefix?] [prefix prefix?]
@ -223,17 +207,16 @@ to its depth from before evaluating the form.}
(listof module-path-index?)))] (listof module-path-index?)))]
[body (listof (or/c form? any/c))] [body (listof (or/c form? any/c))]
[syntax-body (listof (or/c def-syntaxes? def-for-syntax?))] [syntax-body (listof (or/c def-syntaxes? def-for-syntax?))]
[unexported (list/c (listof symbol?) (listof symbol?) [unexported (list/c (listof symbol?)
(listof symbol?)
(listof symbol?))] (listof symbol?))]
[max-let-depth exact-nonnegative-integer?] [max-let-depth exact-nonnegative-integer?]
[dummy toplevel?] [dummy toplevel?]
[lang-info (or/c #f (vector/c module-path? symbol? any/c))] [lang-info (or/c #f (vector/c module-path? symbol? any/c))]
[internal-context (or/c #f #t stx?)])]{ [internal-context (or/c #f #t stx?)])]{
Represents a @racket[module] declaration. The @racket[body] forms use Represents a @racket[module] declaration. The @racket[body] forms use
@racket[prefix], rather than any prefix in place for the module @racket[prefix], rather than any prefix in place for the module
declaration itself (and each @racket[syntax-body] has its own declaration itself (and each @racket[syntax-body] has its own prefix).
prefix).
The @racket[provides] and @racket[requires] lists are each an The @racket[provides] and @racket[requires] lists are each an
association list from phases to exports or imports. In the case of association list from phases to exports or imports. In the case of
@ -261,33 +244,33 @@ provides information about the module's implementation language.
The @racket[internal-module-context] value describes the lexical The @racket[internal-module-context] value describes the lexical
context of the body of the module. This value is used by context of the body of the module. This value is used by
@racket[module->namespace]. A @racket[#f] value means that the context @racket[module->namespace]. A @racket[#f] value means that the
is unavailable or empty. A @racket[#t] value means that the context is context is unavailable or empty. A @racket[#t] value means that the
computed by re-importing all required modules. A syntax-object value context is computed by re-importing all required modules. A
embeds an arbitrary lexical context.} syntax-object value embeds an arbitrary lexical context.}
@defstruct+[provided ([name symbol?] @defstruct+[provided
([name symbol?]
[src (or/c module-path-index? #f)] [src (or/c module-path-index? #f)]
[src-name symbol?] [src-name symbol?]
[nom-mod (or/c module-path-index? #f)] [nom-mod (or/c module-path-index? #f)]
[src-phase (or/c 0 1)] [src-phase (or/c 0 1)]
[protected? boolean?] [protected? boolean?]
[insp (or #t #f void?)])]{ [insp (or #t #f void?)])]{
Describes an individual provided identifier within a @racket[mod]
Describes an individual provided identifier within a @racket[mod] instance.} instance.}
@; -------------------------------------------------- @; --------------------------------------------------
@section{Expressions} @section{Expressions}
@defstruct+[(expr form) ()]{ @defstruct+[(expr form) ()]{
A supertype for all expression forms that can appear in compiled code, A supertype for all expression forms that can appear in compiled code,
except for literals that are represented as themselves and some @racket[seq] except for literals that are represented as themselves and some
structures (which can appear as an expression as long as it contains @racket[seq] structures (which can appear as an expression as long as
only other things that can be expressions).} it contains only other things that can be expressions).}
@defstruct+[(lam expr)
@defstruct+[(lam expr) ([name (or/c symbol? vector?)] ([name (or/c symbol? vector?)]
[flags (listof (or/c 'preserves-marks 'is-method 'single-result 'only-rest-arg-not-used))] [flags (listof (or/c 'preserves-marks 'is-method 'single-result 'only-rest-arg-not-used))]
[num-params exact-nonnegative-integer?] [num-params exact-nonnegative-integer?]
[param-types (listof (or/c 'val 'ref 'flonum))] [param-types (listof (or/c 'val 'ref 'flonum))]
@ -296,7 +279,6 @@ only other things that can be expressions).}
[closure-types (listof (or/c 'val/ref 'flonum))] [closure-types (listof (or/c 'val/ref 'flonum))]
[max-let-depth exact-nonnegative-integer?] [max-let-depth exact-nonnegative-integer?]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[lambda] form. The @racket[name] field is a name Represents a @racket[lambda] form. The @racket[name] field is a name
for debugging purposes. The @racket[num-params] field indicates the for debugging purposes. The @racket[num-params] field indicates the
number of arguments accepted by the procedure, not counting a rest number of arguments accepted by the procedure, not counting a rest
@ -310,8 +292,8 @@ local variable), or @racket['flonum] for a flonum argument. The
captured when evaluating the @racket[lambda] form to create a closure. captured when evaluating the @racket[lambda] form to create a closure.
The @racket[closure-types] field provides a corresponding list of The @racket[closure-types] field provides a corresponding list of
types, but no distinction is made between normal values and boxed types, but no distinction is made between normal values and boxed
values; also, this information is redundant, since it can be inferred by values; also, this information is redundant, since it can be inferred
the bindings referenced though @racket[closure-map]. by the bindings referenced though @racket[closure-map].
When the function is called, the rest-argument list (if any) is pushed When the function is called, the rest-argument list (if any) is pushed
onto the stack, then the normal arguments in reverse order, then the onto the stack, then the normal arguments in reverse order, then the
@ -324,28 +306,25 @@ created by @racket[body] plus the arguments and closure-captured
values pushed onto the stack. The @racket[body] field is the values pushed onto the stack. The @racket[body] field is the
expression for the closure's body.} expression for the closure's body.}
@defstruct+[(closure expr)
@defstruct+[(closure expr) ([code lam?] [gen-id symbol?])]{ ([code lam?] [gen-id symbol?])]{
A @racket[lambda] form with an empty closure, which is a procedure A @racket[lambda] form with an empty closure, which is a procedure
constant. The procedure constant can appear multiple times in the constant. The procedure constant can appear multiple times in the
graph of expressions for bytecode, and the @racket[code] field can graph of expressions for bytecode, and the @racket[code] field can be
be a cycle for a recursive constant procedure; the @racket[gen-id] a cycle for a recursive constant procedure; the @racket[gen-id] is
is different for each such constant.} different for each such constant.}
@defstruct+[(case-lam expr) ([name (or/c symbol? vector?)] @defstruct+[(case-lam expr) ([name (or/c symbol? vector?)]
[clauses (listof lam?)])]{ [clauses (listof lam?)])]{
Represents a @racket[case-lambda] form as a combination of Represents a @racket[case-lambda] form as a combination of
@racket[lambda] forms that are tried (in order) based on the number of @racket[lambda] forms that are tried (in order) based on the number of
arguments given.} arguments given.}
@defstruct+[(let-one expr)
@defstruct+[(let-one expr) ([rhs (or/c expr? seq? any/c)] ([rhs (or/c expr? seq? any/c)]
[body (or/c expr? seq? any/c)] [body (or/c expr? seq? any/c)]
[flonum? boolean?] [flonum? boolean?]
[unused? boolean?])]{ [unused? boolean?])]{
Pushes an uninitialized slot onto the stack, evaluates @racket[rhs] Pushes an uninitialized slot onto the stack, evaluates @racket[rhs]
and puts its value into the slot, and then runs @racket[body]. If and puts its value into the slot, and then runs @racket[body]. If
@racket[flonum?] is @racket[#t], then @racket[rhs] must produce a @racket[flonum?] is @racket[#t], then @racket[rhs] must produce a
@ -356,25 +335,23 @@ onto the stack (but @racket[rhs] is constrained to produce a single
value). value).
After @racket[rhs] is evaluated, the stack is restored to its depth After @racket[rhs] is evaluated, the stack is restored to its depth
from before evaluating @racket[rhs]. Note that the new slot is created from before evaluating @racket[rhs]. Note that the new slot is
before evaluating @racket[rhs].} created before evaluating @racket[rhs].}
@defstruct+[(let-void expr)
@defstruct+[(let-void expr) ([count exact-nonnegative-integer?] ([count exact-nonnegative-integer?]
[boxes? boolean?] [boxes? boolean?]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Pushes @racket[count] uninitialized slots onto the stack and then runs Pushes @racket[count] uninitialized slots onto the stack and then runs
@racket[body]. If @racket[boxes?] is @racket[#t], then the slots are @racket[body]. If @racket[boxes?] is @racket[#t], then the slots are
filled with boxes that contain @|undefined-const|.} filled with boxes that contain @|undefined-const|.}
@defstruct+[(install-value expr)
@defstruct+[(install-value expr) ([count exact-nonnegative-integer?] ([count exact-nonnegative-integer?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[boxes? boolean?] [boxes? boolean?]
[rhs (or/c expr? seq? any/c)] [rhs (or/c expr? seq? any/c)]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Runs @racket[rhs] to obtain @racket[count] results, and installs them Runs @racket[rhs] to obtain @racket[count] results, and installs them
into existing slots on the stack in order, skipping the first into existing slots on the stack in order, skipping the first
@racket[pos] stack positions. If @racket[boxes?] is @racket[#t], then @racket[pos] stack positions. If @racket[boxes?] is @racket[#t], then
@ -383,24 +360,20 @@ the values are put into existing boxes in the stack slots.
After @racket[rhs] is evaluated, the stack is restored to its depth After @racket[rhs] is evaluated, the stack is restored to its depth
from before evaluating @racket[rhs].} from before evaluating @racket[rhs].}
@defstruct+[(let-rec expr) ([procs (listof lam?)] @defstruct+[(let-rec expr) ([procs (listof lam?)]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[letrec] form with @racket[lambda] bindings. It Represents a @racket[letrec] form with @racket[lambda] bindings. It
allocates a closure shell for each @racket[lambda] form in allocates a closure shell for each @racket[lambda] form in
@racket[procs], installs each onto the stack in previously @racket[procs], installs each onto the stack in previously allocated
allocated slots in reverse order (so that the closure shell for the slots in reverse order (so that the closure shell for the last element
last element of @racket[procs] is installed at stack position of @racket[procs] is installed at stack position @racket[0]), fills
@racket[0]), fills out each shell's closure (where each closure out each shell's closure (where each closure normally references some
normally references some other just-created closures, which is other just-created closures, which is possible because the shells have
possible because the shells have been installed on the stack), and been installed on the stack), and then evaluates @racket[body].}
then evaluates @racket[body].}
@defstruct+[(boxenv expr)
@defstruct+[(boxenv expr) ([pos exact-nonnegative-integer?] ([pos exact-nonnegative-integer?]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Skips @racket[pos] elements of the stack, setting the slot afterward Skips @racket[pos] elements of the stack, setting the slot afterward
to a new box containing the slot's old value, and then runs to a new box containing the slot's old value, and then runs
@racket[body]. This form appears when a @racket[lambda] argument is @racket[body]. This form appears when a @racket[lambda] argument is
@ -408,13 +381,12 @@ mutated using @racket[set!] within its body; calling the function
initially pushes the value directly on the stack, and this form boxes initially pushes the value directly on the stack, and this form boxes
the value so that it can be mutated later.} the value so that it can be mutated later.}
@defstruct+[(localref expr)
@defstruct+[(localref expr) ([unbox? boolean?] ([unbox? boolean?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[clear? boolean?] [clear? boolean?]
[other-clears? boolean?] [other-clears? boolean?]
[flonum? boolean?])]{ [flonum? boolean?])]{
Represents a local-variable reference; it accesses the value in the Represents a local-variable reference; it accesses the value in the
stack slot after the first @racket[pos] slots. If @racket[unbox?] is stack slot after the first @racket[pos] slots. If @racket[unbox?] is
@racket[#t], the stack slot contains a box, and a value is extracted @racket[#t], the stack slot contains a box, and a value is extracted
@ -425,12 +397,11 @@ that can prevent reclamation of the value as garbage). If
the same stack slot may clear after reading. If @racket[flonum?] is the same stack slot may clear after reading. If @racket[flonum?] is
@racket[#t], the slot holds to a flonum value.} @racket[#t], the slot holds to a flonum value.}
@defstruct+[(toplevel expr)
@defstruct+[(toplevel expr) ([depth exact-nonnegative-integer?] ([depth exact-nonnegative-integer?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[const? boolean?] [const? boolean?]
[ready? boolean?])]{ [ready? boolean?])]{
Represents a reference to a top-level or imported variable via the Represents a reference to a top-level or imported variable via the
@racket[prefix] array. The @racket[depth] field indicates the number @racket[prefix] array. The @racket[depth] field indicates the number
of stack slots to skip to reach the prefix array, and @racket[pos] is of stack slots to skip to reach the prefix array, and @racket[pos] is
@ -443,42 +414,38 @@ value might change in the future). If @racket[const?] and
@racket[ready?] are both @racket[#f], then a check is needed to @racket[ready?] are both @racket[#f], then a check is needed to
determine whether the variable is defined.} determine whether the variable is defined.}
@defstruct+[(topsyntax expr)
@defstruct+[(topsyntax expr) ([depth exact-nonnegative-integer?] ([depth exact-nonnegative-integer?]
[pos exact-nonnegative-integer?] [pos exact-nonnegative-integer?]
[midpt exact-nonnegative-integer?])]{ [midpt exact-nonnegative-integer?])]{
Represents a reference to a quoted syntax object via the Represents a reference to a quoted syntax object via the
@racket[prefix] array. The @racket[depth] field indicates the number @racket[prefix] array. The @racket[depth] field indicates the number
of stack slots to skip to reach the prefix array, and @racket[pos] is of stack slots to skip to reach the prefix array, and @racket[pos] is
the offset into the array. The @racket[midpt] value is used internally the offset into the array. The @racket[midpt] value is used
for lazy calculation of syntax information.} internally for lazy calculation of syntax information.}
@defstruct+[(application expr)
@defstruct+[(application expr) ([rator (or/c expr? seq? any/c)] ([rator (or/c expr? seq? any/c)]
[rands (listof (or/c expr? seq? any/c))])]{ [rands (listof (or/c expr? seq? any/c))])]{
Represents a function call. The @racket[rator] field is the
Represents a function call. The @racket[rator] field is the expression expression for the function, and @racket[rands] are the argument
for the function, and @racket[rands] are the argument
expressions. Before any of the expressions are evaluated, expressions. Before any of the expressions are evaluated,
@racket[(length rands)] uninitialized stack slots are created (to be @racket[(length rands)] uninitialized stack slots are created (to be
used as temporary space).} used as temporary space).}
@defstruct+[(branch expr)
@defstruct+[(branch expr) ([test (or/c expr? seq? any/c)] ([test (or/c expr? seq? any/c)]
[then (or/c expr? seq? any/c)] [then (or/c expr? seq? any/c)]
[else (or/c expr? seq? any/c)])]{ [else (or/c expr? seq? any/c)])]{
Represents an @racket[if] form. Represents an @racket[if] form.
After @racket[test] is evaluated, the stack is restored to its depth After @racket[test] is evaluated, the stack is restored to its depth
from before evaluating @racket[test].} from before evaluating @racket[test].}
@defstruct+[(with-cont-mark expr)
@defstruct+[(with-cont-mark expr) ([key (or/c expr? seq? any/c)] ([key (or/c expr? seq? any/c)]
[val (or/c expr? seq? any/c)] [val (or/c expr? seq? any/c)]
[body (or/c expr? seq? any/c)])]{ [body (or/c expr? seq? any/c)])]{
Represents a @racket[with-continuation-mark] expression. Represents a @racket[with-continuation-mark] expression.
After each of @racket[key] and @racket[val] is evaluated, the stack is After each of @racket[key] and @racket[val] is evaluated, the stack is
@ -486,22 +453,18 @@ restored to its depth from before evaluating @racket[key] or
@racket[val].} @racket[val].}
@defstruct+[(beg0 expr) ([seq (listof (or/c expr? seq? any/c))])]{ @defstruct+[(beg0 expr) ([seq (listof (or/c expr? seq? any/c))])]{
Represents a @racket[begin0] expression. Represents a @racket[begin0] expression.
After each expression in @racket[seq] is evaluated, the stack is After each expression in @racket[seq] is evaluated, the stack is
restored to its depth from before evaluating the expression.} restored to its depth from before evaluating the expression.}
@defstruct+[(varref expr) ([toplevel toplevel?])]{ @defstruct+[(varref expr) ([toplevel toplevel?])]{
Represents a @racket[#%variable-reference] form.} Represents a @racket[#%variable-reference] form.}
@defstruct+[(assign expr)
@defstruct+[(assign expr) ([id toplevel?] ([id toplevel?]
[rhs (or/c expr? seq? any/c)] [rhs (or/c expr? seq? any/c)]
[undef-ok? boolean?])]{ [undef-ok? boolean?])]{
Represents a @racket[set!] expression that assigns to a top-level or Represents a @racket[set!] expression that assigns to a top-level or
module-level variable. (Assignments to local variables are represented module-level variable. (Assignments to local variables are represented
by @racket[install-value] expressions.) by @racket[install-value] expressions.)
@ -509,62 +472,57 @@ by @racket[install-value] expressions.)
After @racket[rhs] is evaluated, the stack is restored to its depth After @racket[rhs] is evaluated, the stack is restored to its depth
from before evaluating @racket[rhs].} from before evaluating @racket[rhs].}
@defstruct+[(apply-values expr)
@defstruct+[(apply-values expr) ([proc (or/c expr? seq? any/c)] ([proc (or/c expr? seq? any/c)]
[args-expr (or/c expr? seq? any/c)])]{ [args-expr (or/c expr? seq? any/c)])]{
Represents @racket[(call-with-values (lambda () args-expr) proc)], Represents @racket[(call-with-values (lambda () args-expr) proc)],
which is handled specially by the run-time system.} which is handled specially by the run-time system.}
@defstruct+[(primval expr) ([id exact-nonnegative-integer?])]{ @defstruct+[(primval expr)
([id exact-nonnegative-integer?])]{
Represents a direct reference to a variable imported from the run-time Represents a direct reference to a variable imported from the run-time
kernel.} kernel.}
@; -------------------------------------------------- @; --------------------------------------------------
@section{Syntax Objects} @section{Syntax Objects}
@defstruct+[(wrapped zo) ([datum any/c] @defstruct+[(wrapped zo)
([datum any/c]
[wraps (listof wrap?)] [wraps (listof wrap?)]
[certs (or/c certificate? #f)])]{ [certs (or/c certificate? #f)])]{
Represents a syntax object, where @racket[wraps] contain the lexical Represents a syntax object, where @racket[wraps] contain the lexical
information and @racket[certs] is certificate information. When the information and @racket[certs] is certificate information. When the
@racket[datum] part is itself compound, its pieces are wrapped, too.} @racket[datum] part is itself compound, its pieces are wrapped, too.}
@defstruct+[(certificate zo) ()]{ @defstruct+[(certificate zo) ()]{
A supertype for syntax certificates.} A supertype for syntax certificates.}
@defstruct+[(certificate:nest certificate) ([nested (listof number? module-path-index? ...)] @defstruct+[(certificate:nest certificate)
([nested (listof number? module-path-index? ...)]
[map (listof number? module-path-index? ...)])]{ [map (listof number? module-path-index? ...)])]{
A nested certificate.} A nested certificate.}
@defstruct+[(certificate:ref certificate) ([val any/c] @defstruct+[(certificate:ref certificate)
([val any/c]
[map (listof number? module-path-index? ...)])]{ [map (listof number? module-path-index? ...)])]{
A reference certificate.} A reference certificate.}
@defstruct+[(certificate:plain certificate) ([map (listof number? module-path-index? ...)])]{ @defstruct+[(certificate:plain certificate)
([map (listof number? module-path-index? ...)])]{
A plain certificate.} A plain certificate.}
@defstruct+[(wrap zo) ()]{ @defstruct+[(wrap zo) ()]{
A supertype for lexical-information elements.} A supertype for lexical-information elements.}
@defstruct+[(top-level-rename wrap) ([flag boolean?])]{ @defstruct+[(top-level-rename wrap) ([flag boolean?])]{
A top-level renaming.} A top-level renaming.}
@defstruct+[(mark-barrier wrap) ([value symbol?])]{ @defstruct+[(mark-barrier wrap) ([value symbol?])]{
A mark barrier.} A mark barrier.}
@defstruct+[(free-id-info zo) ([path0 module-path-index?] @defstruct+[(free-id-info zo)
([path0 module-path-index?]
[symbol0 symbol?] [symbol0 symbol?]
[path1 module-path-index?] [path1 module-path-index?]
[symbol1 symbol?] [symbol1 symbol?]
@ -574,100 +532,95 @@ A mark barrier.}
[use-current-inspector? boolean?])]{ [use-current-inspector? boolean?])]{
Information about a free identifier.} Information about a free identifier.}
@defstruct+[(lexical-rename wrap) ([has-free-id-info? boolean?] @defstruct+[(lexical-rename wrap)
([has-free-id-info? boolean?]
[bool2 boolean?] [bool2 boolean?]
[alist (listof [alist
(listof
(cons/c symbol? (cons/c symbol?
(or/c (or/c symbol?
symbol? (cons/c symbol?
(cons/c (or/c (cons/c symbol? (or/c symbol? #f))
symbol?
(or/c
(cons/c symbol? (or/c symbol? #f))
free-id-info?)))))])]{ free-id-info?)))))])]{
A local-binding mapping from symbols to binding-set names.} A local-binding mapping from symbols to binding-set names.}
@defstruct+[(phase-shift wrap) ([amt exact-integer?] @defstruct+[(phase-shift wrap)
([amt exact-integer?]
[src module-path-index?] [src module-path-index?]
[dest module-path-index?])]{ [dest module-path-index?])]{
Shifts module bindings later in the wrap set.} Shifts module bindings later in the wrap set.}
@defstruct+[(module-rename wrap) ([phase exact-integer?] @defstruct+[(module-rename wrap)
([phase exact-integer?]
[kind (or/c 'marked 'normal)] [kind (or/c 'marked 'normal)]
[set-id any/c] [set-id any/c]
[unmarshals (listof make-all-from-module?)] [unmarshals (listof make-all-from-module?)]
[renames (listof module-binding?)] [renames (listof module-binding?)]
[mark-renames any/c] [mark-renames any/c]
[plus-kern? boolean?])]{ [plus-kern? boolean?])]{
Represents a set of module and import bindings.} Represents a set of module and import bindings.}
@defstruct+[(all-from-module zo) ([path module-path-index?] @defstruct+[(all-from-module zo)
([path module-path-index?]
[phase (or/c exact-integer? #f)] [phase (or/c exact-integer? #f)]
[src-phase (or/c exact-integer? #f)] [src-phase (or/c exact-integer? #f)]
[exceptions (listof (or/c symbol? number?))] [exceptions (listof (or/c symbol? number?))]
[prefix (or/c symbol? #f)])]{ [prefix (or/c symbol? #f)])]{
Represents a set of simple imports from one module within a Represents a set of simple imports from one module within a
@racket[module-rename].} @racket[module-rename].}
@defstruct+[(module-binding zo) ()]{ @defstruct+[(module-binding zo) ()]{
A supertype for module bindings.} A supertype for module bindings.}
@defstruct+[(simple-module-binding module-binding) ([path module-path-index?])]{ @defstruct+[(simple-module-binding module-binding)
([path module-path-index?])]{
Represents a single identifier import within a
@racket[module-rename].}
Represents a single identifier import within @defstruct+[(phased-module-binding module-binding)
a @racket[module-rename].} ([path module-path-index?]
@defstruct+[(phased-module-binding module-binding) ([path module-path-index?]
[phase exact-integer?] [phase exact-integer?]
[export-name any/c] [export-name any/c]
[nominal-path nominal-path?] [nominal-path nominal-path?]
[nominal-export-name any/c])]{ [nominal-export-name any/c])]{
Represents a single identifier import within a
@racket[module-rename].}
Represents a single identifier import within @defstruct+[(exported-nominal-module-binding module-binding)
a @racket[module-rename].} ([path module-path-index?]
@defstruct+[(exported-nominal-module-binding module-binding) ([path module-path-index?]
[export-name any/c] [export-name any/c]
[nominal-path nominal-path?] [nominal-path nominal-path?]
[nominal-export-name any/c])]{ [nominal-export-name any/c])]{
Represents a single identifier import within a
@racket[module-rename].}
Represents a single identifier import within @defstruct+[(nominal-module-binding module-binding)
a @racket[module-rename].} ([path module-path-index?]
@defstruct+[(nominal-module-binding module-binding) ([path module-path-index?]
[nominal-path nominal-path?])]{ [nominal-path nominal-path?])]{
Represents a single identifier import within a
@racket[module-rename].}
Represents a single identifier import within @defstruct+[(exported-module-binding module-binding)
a @racket[module-rename].} ([path module-path-index?]
@defstruct+[(exported-module-binding module-binding) ([path module-path-index?]
[export-name any/c])]{ [export-name any/c])]{
Represents a single identifier import within a
Represents a single identifier import within @racket[module-rename].}
a @racket[module-rename].}
@defstruct+[(nominal-path zo) ()]{ @defstruct+[(nominal-path zo) ()]{
A supertype for nominal paths.} A supertype for nominal paths.}
@defstruct+[(simple-nominal-path nominal-path) ([value module-path-index?])]{ @defstruct+[(simple-nominal-path nominal-path)
([value module-path-index?])]{
Represents a simple nominal path.} Represents a simple nominal path.}
@defstruct+[(imported-nominal-path nominal-path) ([value module-path-index?] @defstruct+[(imported-nominal-path nominal-path)
([value module-path-index?]
[import-phase exact-integer?])]{ [import-phase exact-integer?])]{
Represents an imported nominal path.} Represents an imported nominal path.}
@defstruct+[(phased-nominal-path nominal-path) ([value module-path-index?] @defstruct+[(phased-nominal-path nominal-path)
([value module-path-index?]
[import-phase (or/c false/c exact-integer?)] [import-phase (or/c false/c exact-integer?)]
[phase exact-integer?])]{ [phase exact-integer?])]{
Represents a phased nominal path.} Represents a phased nominal path.}

828
collects/scribblings/tools/language.scrbl
View File

File diff suppressed because it is too large Load Diff

5
collects/scribblings/tools/unit.scrbl
View File

@ -713,7 +713,10 @@ that the button is not referenced by this frame and thus can be gc'd.
} }
@defclass[drracket:unit:definitions-text% (drracket:rep:drs-bindings-keymap-mixin (drracket:unit:program-editor-mixin (scheme:text-mixin text:info%))) (drracket:unit:definitions-text<%>)]{ @defclass[drracket:unit:definitions-text%
(drracket:rep:drs-bindings-keymap-mixin
(drracket:unit:program-editor-mixin (scheme:text-mixin text:info%)))
(drracket:unit:definitions-text<%>)]{
@defconstructor[()]{ @defconstructor[()]{
Passes all arguments to @scheme[super-init]. Passes all arguments to @scheme[super-init].