fix copy of rator in finish_optimize_application3

POSIX and ANSI specify that char is always 1 byte, and I'm almost
certain that no systems violate this. Regardless, the SIZEOF_CHAR macro
is never used.

.gitignore

@@ -24,3 +24,10 @@ compiled/
 .DS_Store
 *.bak
 TAGS
+
+# generated by patch
+*.orig
+*.rej
+
+# coredumps
+*.core

.travis.yml

@@ -1,56 +1,58 @@
+sudo: false
 language: c
 matrix:
   include:
-    # osx, defaults, gcc and clang
   - os: osx
     compiler: gcc
     env: PATH=./racket/bin:$PATH
   - os: osx
     compiler: clang
     env: PATH=./racket/bin:$PATH
-    # linux, defaults, gcc and clang
   - os: linux
     compiler: gcc
     env: PATH=./racket/bin:$PATH
   - os: linux
     compiler: clang
     env: PATH=./racket/bin:$PATH
-    # linux, no places, no futures, no extflonum, gcc
   - os: linux
     compiler: gcc
-      env: PATH=./racket/bin:$PATH RACKET_CONFIGURE_ARGS="--disable-places --disable-futures --disable-extflonum"
+    env: PATH=./racket/bin:$PATH RACKET_CONFIGURE_ARGS="--disable-places --disable-futures
-    # linux, no jit, gcc
+      --disable-extflonum"
   - os: linux
     compiler: gcc
     env: PATH=./racket/bin:$PATH RACKET_CONFIGURE_ARGS="--disable-jit"
-    # linux, no jit, no places, no futures, no extflonum, gcc
   - os: linux
     compiler: gcc
-      env: PATH=./racket/bin:$PATH RACKET_CONFIGURE_ARGS="--disable-jit --disable-places --disable-futures --disable-extflonum"
+    env: PATH=./racket/bin:$PATH RACKET_CONFIGURE_ARGS="--disable-jit --disable-places
-# Just run tests for the core
+      --disable-futures --disable-extflonum"
+before_script:
+- git config --global user.email "travis-test@racket-lang.org"
+- git config --global user.name "Travis Tester"
 script:
-  - make CPUS="2" PKGS="racket-test db-test unstable-flonum-lib net-test" CONFIGURE_ARGS_qq="$RACKET_CONFIGURE_ARGS"
+- make CPUS="2" PKGS="racket-test db-test unstable-flonum-lib net-test" CONFIGURE_ARGS_qq="$RACKET_CONFIGURE_ARGS"
-  - raco test -l tests/racket/test
+- raco test -l tests/racket/test
-  - racket -l tests/racket/contract/all
+- racket -l tests/pkg/test -- -q
-  - raco test -l tests/json/json
+- racket -l tests/racket/contract/all
-  - raco test -l tests/file/main
+- raco test -l tests/json/json
-  - raco test -l tests/net/head
+- raco test -l tests/file/main
-  - raco test -l tests/net/uri-codec
+- raco test -l tests/net/head
-  - raco test -l tests/net/url
+- raco test -l tests/net/uri-codec
-  - raco test -l tests/net/url-port
+- raco test -l tests/net/url
-  - raco test -l tests/net/encoders
+- raco test -l tests/net/url-port
-  - raco test -l tests/openssl/basic
+- raco test -l tests/net/encoders
-  - raco test -l tests/openssl/https
+- raco test -l tests/openssl/basic
-  - raco test -l tests/match/plt-match-tests
+- raco test -l tests/openssl/https
-  - raco test -l tests/zo-path
+- raco test -l tests/match/main
-  - raco test -l tests/xml/test
+- raco test -l tests/zo-path
-  - raco test -l tests/db/all-tests
+- raco test -l tests/xml/test
+- raco test -l tests/db/all-tests
 notifications:
-  irc: "chat.freenode.net#racket-dev"
+  irc: chat.freenode.net#racket-dev
   email:
     recipients:
     - samth@racket-lang.org
     - robby@racket-lang.org
     - mflatt@racket-lang.org
     on_success: change
-
+  slack:
+    secure: A19kphrabQHO8TU6qZcBaLQxdSNpm1ypEtbQsh8Ucg6HYPP7y1q7O7JZEndoMRHE9CNKZ9oXQzqR8H1IFVTlnjFFIJfkZzZ1YSNk4abSomhpWCq9daKMfwlcuTtY6PeI1nDVpka4/hiJGn9qzmaKYXle9Sl4CX2VEYp8o8PgMEs=

INSTALL.txt

@@ -1,8 +1,8 @@
 Build Options
 =============
 
-For Unix platforms, instead of using this source repository, consider
+Instead of using this source repository, consider getting source for
-getting source for the current Racket release from
+the current Racket release from
 
   http://download.racket-lang.org/
 
@@ -16,7 +16,9 @@ documentation are pre-built.
 
 In contrast to this repository, release and snapshot source
 distributions will work in the
+
   configure --prefix=... && make && make install
+
 way that you probably expect.
 
 
@@ -31,7 +33,7 @@ If you stick with this repository, then you have several options:
    Instructions: In-place Build" below.
 
  * Unix-style install --- installs to a given destination directory
-   (Unix and Mac OS X, only), leaving no reference to the source
+   (on platforms other Windows), leaving no reference to the source
    directory. This is the most natural mode for installing once from
    the source repository. See "Quick Instructions: Unix-style Install"
    below.
@@ -51,11 +53,11 @@ If you stick with this repository, then you have several options:
 Quick Instructions: In-place Build
 ==================================
 
-On Unix, `make' (or `make in-place') creates a build in the "racket"
+On Unix (including Linux) and Mac OS X, `make' (or `make in-place')
-directory.
+creates a build in the "racket" directory.
 
 On Windows with Microsoft Visual Studio (any version between 2008/9.0
-and 2013/12.0), `nmake win32-in-place' creates a build in the "racket"
+and 2015/14.0), `nmake win32-in-place' creates a build in the "racket"
 directory. For information on configuring your command-line
 environment for Visual Studio, see "racket/src/worksp/README".
 
@@ -74,10 +76,10 @@ See "More Instructions: Building Racket" below for more information.
 Quick Instructions: Unix-style Install
 ======================================
 
-On Unix, `make unix-style PREFIX=<dir>' builds and installs into
+On Unix (including Linux), `make unix-style PREFIX=<dir>' builds and
-"<dir>" (which must be an absolute path) with binaries in "<dir>/bin",
+installs into "<dir>" (which must be an absolute path) with binaries
-packages in "<dir>/share/racket/pkgs", documentation in
+in "<dir>/bin", packages in "<dir>/share/racket/pkgs", documentation
-"<dir>/share/racket/doc", etc.
+in "<dir>/share/racket/doc", etc.
 
 On Mac OS X, `make unix-style PREFIX=<dir>' builds and installs into
 "<dir>" (whichmust be an absolute path) with binaries in "<dir>/bin",
@@ -128,6 +130,12 @@ previously installed packages remain installed and are updated, while
 new packages are added. To uninstall previously selected package, use
 `raco pkg remove'.
 
+To build anything other than the latest sources in the repository
+(e.g., when building from the "v6.2.1" tag), you need a catalog
+that's compatible with those sources. Note that a release distribution
+is configured to use a catalog specific to that release, so you can
+extract the catalog's URL from there.
+
 Using `make' (or `make in-place') sets the installation's name to
 "development", unless the installation has been previously configured
 (i.e., unless the "racket/etc/config.rktd" file exists). The
@@ -181,10 +189,17 @@ but under Windows, encoding-conversion, extflonum, and SSL
 functionality is hobbled until native libraries from the
 `racket-win32-i386' or `racket-win32-x86_64' package are installed.
 
-On all platforms, `JOB_OPTIONS' as a makefile variable and
+On all platforms, fom the top-level makefile, `JOB_OPTIONS' as a
-`PLT_SETUP_OPTIONS' as an environment variable are passed on to the
+makefile variable and `PLT_SETUP_OPTIONS' as an environment variable
-`raco setup' that is used to build minimal-Racket libraries. See the
+are passed on to the `raco setup' that is used to build minimal-Racket
-documentation for `raco setup' for information on the options.
+libraries. See the documentation for `raco setup' for information on
+the options.
+
+For cross compilation, add configuration options to
+`CONFIGURE_ARGS_qq="..."' as descibed in the "README" of "racket/src",
+but also add a `PLAIN_RACKET=...' argument for the top-level makefile
+to specify the same executable as in an `--enable-racket=...' for
+`configure'.
 
 Installing Packages
 -------------------
@@ -305,8 +320,8 @@ where <dist-base> defaults to "racket" (but can be set via
 normalizing the Windows results to "i386-win32" and "x86_63-win32",
 -<dist-suffix> is omitted unless a `#:dist-suffix' string is specified
 for the client in the site configuration, and <ext> is
-platform-specific: ".sh" for Unix, ".dmg" or ".pkg" for Mac OS X, and
+platform-specific: ".sh" for Unix (including Linux), ".dmg" or ".pkg"
-".exe" for Windows.
+for Mac OS X, and ".exe" for Windows.
 
 Generating Installer Web Sites
 ------------------------------
@@ -475,8 +490,8 @@ In more detail:
      To change the base name of the installer file, provide `DIST_BASE'
      to `make'. The default is "racket".
 
-     To change the directory name for Unix installation, provide
+     To change the directory name for installation on Unix (including
-     `DIST_DIR' to `make'. The default is "racket".
+     Linux), provide `DIST_DIR' to `make'. The default is "racket".
 
      To add an extra piece to the installer's name, such as an
      identifier for a variant of Linux, provide `DIST_SUFFIX' to
@@ -499,12 +514,20 @@ In more detail:
      `make'. The `README' value is used as a file name to download
      from the server.
 
-     For a Mac OS X installer, set `SIGN_IDENTITY' to sign the
+     To create a ".tgz" archive instead of an installer (or any
-     installer, where the value of `SIGN_IDENTITY' is the name to
+     platform), set `TGZ_MODE' to "--tgz".
+
+     For a Mac OS X installer, set `SIGN_IDENTITY' as the name to
      which the signing certificate is associated. Set `MAC_PKG_MODE'
      to "--mac-pkg" to create a ".pkg" installer instead of a ".dmg"
      image.
 
+     For a Windows installer, set `OSSLSIGNCODE_ARGS_BASE64` as a
+     Base64 encoding of an S-expression for a list of argument strings
+     for `osslsigncode`. The `-n', `-t', `-in', and `-out' arguments
+     are provided to `osslsigncode` automatically, so supply the
+     others.
+
      The `SERVER_CATALOG_PATH' and `SERVER_COLLECTS_PATH' makefile
      variables specify paths at `SERVER' plus `SERVER_PORT' to access
      the package catalog and pre-built "collects" tree needed for a

Makefile

@@ -29,13 +29,18 @@ PKGS = main-distribution main-distribution-test
 PLAIN_RACKET = racket/bin/racket
 WIN32_PLAIN_RACKET = racket\racket
 
-PLAIN_RACO = racket/bin/racket -N raco -l- raco
+# In case of cross-installation, point explicitly to local content:
-WIN32_PLAIN_RACO = racket\racket -N raco -l- raco
+RUN_RACKET = $(PLAIN_RACKET) -G racket/etc -X racket/collects
+WIN32_RUN_RACKET = $(WIN32_PLAIN_RACKET) -G racket/etc -X racket/collects
 
-DEFAULT_SRC_CATALOG = http://pkgs.racket-lang.org
+RUN_RACO = $(RUN_RACKET) -N raco -l- raco
+WIN32_RUN_RACO = $(WIN32_RUN_RACKET) -N raco -l- raco
 
-MACOSX_CHECK_ARGS = -I racket/base -e '(case (system-type) [(macosx) (exit 0)] [else (exit 1)])'
+DEFAULT_SRC_CATALOG = https://pkgs.racket-lang.org
-MACOSX_CHECK = $(PLAIN_RACKET) -G build/config $(MACOSX_CHECK_ARGS)
+
+# Belongs in the "Configuration options" section, but here
+# to accomodate nmake:
+SRC_CATALOG = $(DEFAULT_SRC_CATALOG)
 
 CPUS = 
 
@@ -61,18 +66,18 @@ ALL_PLT_SETUP_OPTIONS = $(JOB_OPTIONS) $(PLT_SETUP_OPTIONS)
 plain-in-place:
 	$(MAKE) base
 	$(MAKE) pkgs-catalog
-	$(PLAIN_RACO) pkg update $(UPDATE_PKGS_ARGS)
+	$(RUN_RACO) pkg update $(UPDATE_PKGS_ARGS)
-	$(PLAIN_RACO) pkg install $(INSTALL_PKGS_ARGS)
+	$(RUN_RACO) pkg install $(INSTALL_PKGS_ARGS)
-	$(PLAIN_RACO) setup --only-foreign-libs $(ALL_PLT_SETUP_OPTIONS)
+	$(RUN_RACO) setup --only-foreign-libs $(ALL_PLT_SETUP_OPTIONS)
-	$(PLAIN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
+	$(RUN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
 
 win32-in-place:
 	$(MAKE) win32-base
-	$(MAKE) win32-pkgs-catalog
+	$(MAKE) win32-pkgs-catalog SRC_CATALOG="$(SRC_CATALOG)"
-	$(WIN32_PLAIN_RACO) pkg update $(UPDATE_PKGS_ARGS)
+	$(WIN32_RUN_RACO) pkg update $(UPDATE_PKGS_ARGS)
-	$(WIN32_PLAIN_RACO) pkg install $(INSTALL_PKGS_ARGS)
+	$(WIN32_RUN_RACO) pkg install $(INSTALL_PKGS_ARGS)
-	$(WIN32_PLAIN_RACO) setup --only-foreign-libs $(ALL_PLT_SETUP_OPTIONS)
+	$(WIN32_RUN_RACO) setup --only-foreign-libs $(ALL_PLT_SETUP_OPTIONS)
-	$(WIN32_PLAIN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
+	$(WIN32_RUN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
 
 # Rebuild without consulting catalogs or package sources:
 
@@ -86,11 +91,11 @@ cpus-as-is:
 
 plain-as-is:
 	$(MAKE) base
-	$(PLAIN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
+	$(RUN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
 
 win32-as-is:
 	$(MAKE) win32-base
-	$(WIN32_PLAIN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
+	$(WIN32_RUN_RACO) setup $(ALL_PLT_SETUP_OPTIONS)
 
 # ------------------------------------------------------------
 # Unix-style build (Unix and Mac OS X, only)
@@ -171,6 +176,17 @@ win32-remove-setup-dlls:
 racket/src/build/Makefile: racket/src/configure racket/src/Makefile.in
 	cd racket/src/build; ../configure $(CONFIGURE_ARGS_qq)
 
+
+# For cross-compilation, build a native executable with no configure options:
+native-for-cross:
+	mkdir -p racket/src/build/cross
+	$(MAKE) racket/src/build/cross/Makefile
+	cd racket/src/build/cross; $(MAKE) reconfigure
+	cd racket/src/build/cross/racket; $(MAKE)
+
+racket/src/build/cross/Makefile: racket/src/configure racket/src/Makefile.in
+	cd racket/src/build/cross; ../../configure
+
 # ------------------------------------------------------------
 # Configuration options for building installers
 
@@ -182,8 +198,8 @@ racket/src/build/Makefile: racket/src/configure racket/src/Makefile.in
 # end in "_q" or "_qq", don't use any quote marks on the right-hand
 # side of its definition.
 
-# Catalog for package sources:
+# Catalog for package sources (defined above):
-SRC_CATALOG = $(DEFAULT_SRC_CATALOG)
+# SRC_CATALOG = $(DEFAULT_SRC_CATALOG)
 
 # A URL embedded in documentation for remote searches, where a Racket
 # version and search key are added as query fields to the URL, and ""
@@ -222,6 +238,9 @@ VERSIONLESS_MODE =
 # instead of a ".dmg" for drag-and-drop installation:
 MAC_PKG_MODE =
 
+# Set to "--tgz" to create a ".tgz" archive instead of an installer:
+TGZ_MODE =
+
 # Set to "--source --no-setup" to include packages in an installer
 # (or archive) only in source form:
 PKG_SOURCE_MODE = 
@@ -252,10 +271,14 @@ BUILD_STAMP =
 # the default as the version number:
 INSTALL_NAME =
 
-# A signing identity (spaces allowed) for Mac OS X binaries in an
+# For Mac OS X, a signing identity (spaces allowed) for binaries in an
 # installer:
 SIGN_IDENTITY = 
 
+# For Windows, `osslsigncode' arguments other than `-n', `-t', `-in',
+# and `-out' as a Base64-encoded, S-expression, list of strings:
+OSSLSIGNCODE_ARGS_BASE64 =
+
 # URL for a README file to include in an installer (empty for none,
 # spaces allowed):
 README = http://$(SVR_PRT)/README.txt
@@ -299,11 +322,11 @@ SVR_PRT = $(SERVER):$(SERVER_PORT)
 SVR_CAT = http://$(SVR_PRT)/$(SERVER_CATALOG_PATH)
 
 # Helper macros:
-USER_CONFIG = -G build/user/config -A build/user
+USER_CONFIG = -G build/user/config -X racket/collects -A build/user
-RACKET = racket/bin/racket $(USER_CONFIG)
+RACKET = $(PLAIN_RACKET) $(USER_CONFIG)
-RACO = racket/bin/racket $(USER_CONFIG) -N raco -l- raco
+RACO = $(PLAIN_RACKET) $(USER_CONFIG) -N raco -l- raco
-WIN32_RACKET = racket\racket $(USER_CONFIG)
+WIN32_RACKET = $(WIN32_PLAIN_RACKET) $(USER_CONFIG)
-WIN32_RACO = racket\racket $(USER_CONFIG) -N raco -l- raco
+WIN32_RACO = $(WIN32_PLAIN_RACKET) $(USER_CONFIG) -N raco -l- raco
 X_AUTO_OPTIONS = --skip-installed --deps search-auto --pkgs $(JOB_OPTIONS)
 USER_AUTO_OPTIONS = --scope user $(X_AUTO_OPTIONS)
 LOCAL_USER_AUTO = --catalog build/local/catalog $(USER_AUTO_OPTIONS)
@@ -312,9 +335,9 @@ REMOTE_USER_AUTO = --catalog $(SVR_CAT) $(USER_AUTO_OPTIONS)
 REMOTE_INST_AUTO = --catalog $(SVR_CAT) --scope installation $(X_AUTO_OPTIONS)
 CONFIG_MODE_q = "$(CONFIG)" "$(CONFIG_MODE)"
 BUNDLE_CONFIG = bundle/racket/etc/config.rktd
-BUNDLE_RACO_FLAGS = -A bundle/user -l raco
+BUNDLE_RACO_FLAGS = -G bundle/racket/config -X bundle/racket/collects -A bundle/user -l raco
-BUNDLE_RACO = bundle/racket/bin/racket $(BUNDLE_RACO_FLAGS)
+BUNDLE_RACO = $(PLAIN_RACKET) $(BUNDLE_RACO_FLAGS)
-WIN32_BUNDLE_RACO = bundle\racket\racket $(BUNDLE_RACO_FLAGS)
+WIN32_BUNDLE_RACO = $(WIN32_PLAIN_RACKET) $(BUNDLE_RACO_FLAGS)
 
 # ------------------------------------------------------------
 # Linking all packages (development mode; not an installer build)
@@ -323,12 +346,14 @@ PKGS_CATALOG = -U -G build/config -l- pkg/dirs-catalog --link --check-metadata
 PKGS_CONFIG = -U -G build/config racket/src/pkgs-config.rkt
 
 pkgs-catalog:
-	$(PLAIN_RACKET) $(PKGS_CATALOG) racket/share/pkgs-catalog pkgs
+	$(RUN_RACKET) $(PKGS_CATALOG) racket/share/pkgs-catalog pkgs
-	$(PLAIN_RACKET) $(PKGS_CONFIG) "$(DEFAULT_SRC_CATALOG)" "$(SRC_CATALOG)"
+	$(RUN_RACKET) $(PKGS_CONFIG) "$(DEFAULT_SRC_CATALOG)" "$(SRC_CATALOG)"
-	$(PLAIN_RACKET) racket/src/pkgs-check.rkt racket/share/pkgs-catalog
+	$(RUN_RACKET) racket/src/pkgs-check.rkt racket/share/pkgs-catalog
+
+COPY_PKGS_ARGS = PLAIN_RACKET="$(WIN32_PLAIN_RACKET)" SRC_CATALOG="$(SRC_CATALOG)"
 
 win32-pkgs-catalog:
-	$(MAKE) pkgs-catalog PLAIN_RACKET="$(WIN32_PLAIN_RACKET)"
+	$(MAKE) pkgs-catalog $(COPY_PKGS_ARGS)
 
 # ------------------------------------------------------------
 # On a server platform (for an installer build):
@@ -428,14 +453,15 @@ binary-catalog-server:
 # client is the same as the server.
 
 PROP_ARGS = SERVER=$(SERVER) SERVER_PORT=$(SERVER_PORT) SERVER_HOSTS="$(SERVER_HOSTS)" \
-            PKGS="$(PKGS)" BUILD_STAMP="$(BUILD_STAMP)" \
+            PKGS="$(PKGS)" PLAIN_RACKET="$(PLAIN_RACKET)" BUILD_STAMP="$(BUILD_STAMP)" \
 	    RELEASE_MODE=$(RELEASE_MODE) SOURCE_MODE=$(SOURCE_MODE) \
             VERSIONLESS_MODE=$(VERSIONLESS_MODE) MAC_PKG_MODE=$(MAC_PKG_MODE) \
-            PKG_SOURCE_MODE="$(PKG_SOURCE_MODE)" INSTALL_NAME="$(INSTALL_NAME)"\
+            PKG_SOURCE_MODE="$(PKG_SOURCE_MODE)" INSTALL_NAME="$(INSTALL_NAME)" \
             DIST_NAME="$(DIST_NAME)" DIST_BASE=$(DIST_BASE) \
             DIST_DIR=$(DIST_DIR) DIST_SUFFIX=$(DIST_SUFFIX) UPLOAD="$(UPLOAD)" \
-            DIST_DESC="$(DIST_DESC)" README="$(README)" SIGN_IDENTITY="$(SIGN_IDENTITY)"\
+            DIST_DESC="$(DIST_DESC)" README="$(README)" SIGN_IDENTITY="$(SIGN_IDENTITY)" \
-            JOB_OPTIONS="$(JOB_OPTIONS)"
+            OSSLSIGNCODE_ARGS_BASE64="$(OSSLSIGNCODE_ARGS_BASE64)" JOB_OPTIONS="$(JOB_OPTIONS)" \
+            TGZ_MODE=$(TGZ_MODE)
 
 COPY_ARGS = $(PROP_ARGS) \
             SERVER_CATALOG_PATH=$(SERVER_CATALOG_PATH) SERVER_COLLECTS_PATH=$(SERVER_COLLECTS_PATH)
@@ -476,15 +502,18 @@ bundle-from-server:
 	rm -rf bundle
 	mkdir -p bundle/racket
 	$(RACKET) -l setup/unixstyle-install bundle racket bundle/racket
+	$(RACKET) -l setup/winstrip bundle/racket
+	$(RACKET) -l setup/winvers-change bundle/racket
 	$(RACKET) -l distro-build/unpack-collects http://$(SVR_PRT)/$(SERVER_COLLECTS_PATH)
 	$(BUNDLE_RACO) pkg install $(REMOTE_INST_AUTO) $(PKG_SOURCE_MODE) $(REQUIRED_PKGS)
 	$(BUNDLE_RACO) pkg install $(REMOTE_INST_AUTO) $(PKG_SOURCE_MODE) $(PKGS)
 	$(RACKET) -l setup/unixstyle-install post-adjust "$(SOURCE_MODE)" "$(PKG_SOURCE_MODE)" racket bundle/racket
 
 UPLOAD_q = --readme "$(README)" --upload "$(UPLOAD)" --desc "$(DIST_DESC)"
-DIST_ARGS_q = $(UPLOAD_q) $(RELEASE_MODE) $(SOURCE_MODE) $(VERSIONLESS_MODE) $(MAC_PKG_MODE) \
+DIST_ARGS_q = $(UPLOAD_q) $(RELEASE_MODE) $(SOURCE_MODE) $(VERSIONLESS_MODE) \
+              $(MAC_PKG_MODE) $(TGZ_MODE) \
               "$(DIST_NAME)" $(DIST_BASE) $(DIST_DIR) "$(DIST_SUFFIX)" \
-              "$(SIGN_IDENTITY)"
+              "$(SIGN_IDENTITY)" "$(OSSLSIGNCODE_ARGS_BASE64)"
 
 # Create an installer from the build (with installed packages) that's
 # in "bundle/racket":

README.txt

@@ -5,7 +5,7 @@ License
 -------
 
 Racket
-Copyright (c) 2010-2014 PLT Design Inc.
+Copyright (c) 2010-2016 PLT Design Inc.
 
 Racket is distributed under the GNU Lesser General Public License
 (LGPL).  This implies that you may link Racket into proprietary

appveyor.yml

@@ -8,11 +8,26 @@ cache:
 build_script:
 - '"c:\Program Files (x86)\Microsoft Visual Studio 10.0\vc\vcvarsall.bat" x86'
 - echo %cd%
-- nmake win32-in-place PKGS="racket-test-core"
+- nmake win32-in-place PKGS="racket-test unstable-flonum-lib net-test"
 
 test_script:
 - echo %cd%
+- racket\raco.exe pkg show -l
 - racket\racket.exe -l tests/racket/test
+- racket\racket.exe -l tests/racket/contract/all
+- racket\raco.exe test -l tests/json/json
+- racket\raco.exe test -l tests/file/main
+- racket\raco.exe test -l tests/net/head
+- racket\raco.exe test -l tests/net/uri-codec
+- racket\raco.exe test -l tests/net/url
+- racket\raco.exe test -l tests/net/url-port
+- racket\raco.exe test -l tests/net/encoders
+- racket\raco.exe test -l tests/openssl/basic
+- racket\raco.exe test -l tests/openssl/https
+- racket\raco.exe test -l tests/match/main
+- racket\raco.exe test -l tests/zo-path
+- racket\raco.exe test -l tests/xml/test
+
 
 notifications:
  - provider: Email
@@ -20,3 +35,8 @@ notifications:
     - samth@racket-lang.org
    on_build_success: true
    on_build_failure: true
+
+ - provider: Slack
+   auth_token:
+     secure: WCMkqS/3iB39INmhzQoZDNJ3zcOXLaRueWvaayOD9MW15DcWrGOAxz7dGrhh/EcQ
+   channel: notifications

pkgs/at-exp-lib/LICENSE.txt

@@ -1,5 +1,5 @@
 at-exp-lib
-Copyright (c) 2010-2014 PLT Design Inc.
+Copyright (c) 2010-2016 PLT Design Inc.
 
 This package is distributed under the GNU Lesser General Public
 License (LGPL).  This means that you can link this package into proprietary

pkgs/at-exp-lib/at-exp/lang/language-info.rkt

@@ -2,9 +2,19 @@
 
 (provide get-language-info)
 
+(require racket/match)
+
 (define (get-language-info data)
+  (define other-get-info
+    (match data
+      [(vector mod sym data2)
+       ((dynamic-require mod sym) data2)]
+      [_ (lambda (key default) default)]))
   (lambda (key default)
     (case key
       [(configure-runtime)
-       '(#[at-exp/lang/runtime-config configure #f])]
+       (define config-vec '#[at-exp/lang/runtime-config configure #f])
-      [else default])))
+       (define other-config (other-get-info key default))
+       (cond [(list? other-config) (cons config-vec other-config)]
+             [else (list config-vec)])]
+      [else (other-get-info key default)])))

pkgs/at-exp-lib/at-exp/lang/reader.rkt

@@ -29,9 +29,10 @@
      (lambda (orig-read-syntax)
        (define read-syntax (wrap-reader orig-read-syntax))
        (lambda args
-         (syntax-property (apply read-syntax args)
+         (define stx (apply read-syntax args))
-                          'module-language
+         (define old-prop (syntax-property stx 'module-language))
-                          '#(at-exp/lang/language-info get-language-info #f))))
+         (define new-prop `#(at-exp/lang/language-info get-language-info ,old-prop))
+         (syntax-property stx 'module-language new-prop)))
      (lambda (proc)
        (lambda (key defval)
          (define (fallback) (if proc (proc key defval) defval))

pkgs/base/LICENSE.txt

@@ -1,5 +1,5 @@
 base
-Copyright (c) 2010-2014 PLT Design Inc.
+Copyright (c) 2010-2016 PLT Design Inc.
 
 This package is distributed under the GNU Lesser General Public
 License (LGPL).  This means that you can link this package into proprietary

pkgs/base/info.rkt

@@ -12,7 +12,7 @@
 
 (define collection 'multi)
 
-(define version "6.2.0.900")
+(define version "6.4.0.15")
 
 (define deps `("racket-lib"
                ["racket" #:version ,version]))

pkgs/racket-benchmarks/info.rkt

@@ -6,9 +6,9 @@
                "compatibility-lib"
                "r5rs-lib"
                "scheme-lib"
-               "srfi-lite-lib"
                "racket-test"
-               "typed-racket-lib"))
+               "typed-racket-lib"
+               "gui-lib"))
 
 (define pkg-desc "Racket benchmarks")
 (define pkg-authors '(eli jay mflatt robby samth stamourv))

pkgs/racket-benchmarks/tests/racket/benchmarks/common/auto.rkt

@@ -48,6 +48,19 @@ exec racket -qu "$0" ${1+"$@"}
         (compile-file name
                       "compiled/current-bm_rkt.zo"))))
 
+  (define (mk-errortrace bm)
+    (unless (directory-exists? "compiled")
+      (make-directory "compiled"))
+    (parameterize ([current-namespace (make-base-namespace)]
+                   [read-accept-reader #t]
+                   [current-compile (current-compile)]
+                   [error-display-handler (error-display-handler)]
+                   [use-compiled-file-paths (use-compiled-file-paths)])
+      (dynamic-require 'errortrace #f)
+      (let ([name (format "~a.rkt" bm)])
+        (compile-file name
+                      "compiled/current-bm_rkt.zo"))))
+
   (define (compiled-path bm)
     "current-bm.rkt")
 
@@ -395,6 +408,14 @@ exec racket -qu "$0" ${1+"$@"}
                 extract-racket-times
                 clean-up-zo
                 racket-skip-progs)
+     (make-impl 'errortrace
+                void
+                mk-errortrace
+                (lambda (bm)
+                  (system (format "racket -l errortrace -u ~a" (compiled-path bm))))
+                extract-racket-times
+                clean-up-zo
+                racket-skip-progs)
      (make-impl 'plt-r5rs
                 void
                 mk-plt-r5rs

pkgs/racket-benchmarks/tests/racket/benchmarks/places/place-processes.rkt

@@ -9,7 +9,8 @@
          racket/serialize
          (for-syntax syntax/parse
                      racket/base
-                     racket/file))
+                     racket/file
+                     syntax/strip-context))
 
 (provide
   dynamic-place
@@ -117,7 +118,7 @@
               new-result)))]))
 
 (define-syntax (place/base stx)
-  (syntax-case stx ()
+  (syntax-case (replace-context #'here stx) ()
     [(_ module-name (name ch) body ...)
      #'(module module-name racket/base
          (require "place-processes.rkt")

pkgs/racket-benchmarks/tests/racket/benchmarks/places/symbols.rkt

@@ -10,7 +10,7 @@
   (module pct1 racket/base
     (require racket/place
              racket/match
-             "place-utils.rkt")
+             tests/racket/place-utils)
     (provide place-main)
 
     (define (place-main ch)
@@ -48,7 +48,7 @@ END
   #<<END
   (module pct1 racket/base
     (require racket/place
-             "place-utils.rkt")
+             tests/racket/place-utils)
     (provide place-main)
     (require algol60/parse
              (for-syntax racket/base

pkgs/racket-benchmarks/tests/racket/benchmarks/redrawing-ala-drracket.rkt

@@ -0,0 +1,80 @@
+#lang racket/gui
+#|
+
+This is an attempt to simulate what happens when
+DrRacket redraws a full window's worth of text
+
+|#
+
+(require framework)
+
+(define t%
+  (text:column-guide-mixin
+   (text:line-numbers-mixin
+    racket:text%)))
+
+(define (time-print-mixin t%)
+  (class t%
+    (super-new)
+    (define/override (on-paint before? dc left top right bottom dx dy draw-caret)
+      (cond
+        [before?
+         (set! start-time (current-process-milliseconds (current-thread)))
+         (super on-paint before? dc left top right bottom dx dy draw-caret)]
+        [else
+         (super on-paint before? dc left top right bottom dx dy draw-caret)
+         (define now (current-process-milliseconds (current-thread)))
+         (set! times (cons (- now start-time) times))
+         (semaphore-post s)]))))
+(define start-time #f)
+
+(define times '())
+(define s (make-semaphore))
+(define t (new (time-print-mixin t%)))
+(send t show-line-numbers! #t)
+(send t insert "#lang racket/base\n")
+(for ([x (in-range 1000)])
+  (send t insert (format "~s\n" '(let loop ([x ""])
+                                   (when (< (string-length x) 100)
+                                     (loop (string-append x "y")))))))
+(define f (new frame% [label ""] [width 1000] [height 1400]))
+(define ec (new editor-canvas% [parent f] [editor t]))
+(define height
+  (let ([yb (box 0)])
+    (send t position-location (send t last-position) #f yb)
+    (unbox yb)))
+(define width
+  (let ([xb (box 0)])
+    (for/fold ([width 0]) ([para (in-range (+ (send t last-paragraph) 1))])
+      (send t position-location (send t paragraph-end-position para) xb #f #t #t)
+      (max width (unbox xb)))))
+(void (send ec scroll-to 0 (/ height 2) 1 1 #t))
+(send f show #t)
+
+;; wait for syntax coloring to finish
+(send t freeze-colorer)
+
+(define number-of-experiments 10)
+
+(queue-callback
+ (λ ()
+   (set! times '())
+   (set! s (make-semaphore)) ;; because earlier paints happend before we were ready
+   (for ([i (in-range number-of-experiments)])
+     (collect-garbage) (collect-garbage) (collect-garbage)
+     (send ec refresh)
+     (yield s))
+   (semaphore-post done))
+ #f)
+
+(define done (make-semaphore 0))
+(void (yield done))
+
+;; show the actual times.
+times
+
+;; print in drdr friendly way
+(let ([t (apply + times)])
+  (printf "cpu time: ~a real time: ~a gc time: ~a\n" t t t))
+
+(send f show #f) (exit)

pkgs/racket-benchmarks/tests/racket/benchmarks/shootout/heapsort.rkt

@@ -7,9 +7,6 @@
 
 #lang racket/base
 
-(require (only-in srfi/13 string-index string-pad-right)
-         (only-in mzlib/string real->decimal-string))
-
 (define IM   139968)
 (define IA     3877)
 (define IC    29573)

pkgs/racket-benchmarks/tests/racket/benchmarks/shootout/typed/heapsort.rktl

@@ -5,9 +5,6 @@
 ;;
 ;; Updated by Brent Fulgham to provide proper output formatting
 
-(require (only-in srfi/13 string-index string-pad-right)
-         (only-in mzlib/string real->decimal-string))
-
 (define IM   139968)
 (define IA     3877)
 (define IC    29573)

pkgs/racket-doc/LICENSE.txt

@@ -1,5 +1,5 @@
 racket-doc
-Copyright (c) 2010-2014 PLT Design Inc.
+Copyright (c) 2010-2016 PLT Design Inc.
 
 This package is distributed under the GNU Lesser General Public
 License (LGPL).  This means that you can link this package into proprietary

pkgs/racket-doc/compatibility/scribblings/package.scrbl

@@ -2,7 +2,7 @@
 @(require scribblings/reference/mz (for-label compatibility/package))
 
 @(define pack-eval (make-base-eval))
-@interaction-eval[#:eval pack-eval (require compatibility/package)]
+@examples[#:hidden #:eval pack-eval (require compatibility/package)]
 
 @title[#:tag "compatibility-package"]{Limiting Scope: @racket[define-package], @racket[open-package], ...}
 
@@ -61,11 +61,11 @@ is the exported one.
 (define-package presents (doll)
   (define doll "Molly Coddle")
   (define robot "Destructo"))
-doll
+(eval:error doll)
-robot
+(eval:error robot)
 (open-package presents)
 doll
-robot
+(eval:error robot)
 (define-package big-russian-doll (middle-russian-doll)
   (define-package middle-russian-doll (little-russian-doll)
     (define little-russian-doll "Anastasia")))
@@ -95,7 +95,7 @@ the defined bindings remain hidden outside the
 (package-begin
   (define secret "mimi")
   (list secret))
-secret
+(eval:error secret)
 ]}
 
 @deftogether[(

pkgs/racket-doc/dynext/dynext.scrbl

@@ -9,7 +9,8 @@
              dynext/link-unit
              dynext/link-sig
              dynext/file-unit
-             dynext/file-sig))
+             dynext/file-sig
+             compiler/module-suffix))
 
 @title{Dynext: Running a C Compiler/Linker}
 
@@ -359,7 +360,11 @@ Appends the platform-standard dynamic-extension file suffix to
          (or/c path? false/c)]{
 
 Strips the Racket file suffix from @racket[s] and returns a stripped
-path. Unlike the other functions below, when @racket[program] is not
+path. The recognized suffixes are the ones reported by
+@racket[(get-module-suffixes #:group 'libs)] when
+@racket[extract-base-filename/ss] is first called.
+
+Unlike the other functions below, when @racket[program] is not
 @racket[#f], then any suffix (including no suffix) is allowed. If
 @racket[s] is not a Racket file and @racket[program] is @racket[#f],
 @racket[#f] is returned.}

pkgs/racket-doc/file/scribblings/convertible.scrbl

@@ -31,7 +31,7 @@ should be considered standard:
         and eight numbers; like @racket['png-bytes+bounds], but where
         the image encoded that is in the byte string can be padded in
         each direction (to allow the drawn region to extend beyond
-        it's ``bounding box''), where the extra four numbers in the
+        its ``bounding box''), where the extra four numbers in the
         list specify the amount of padding that was added to the
         image: left, right, top, and bottom}
  @item{@racket['png@2x-bytes] --- like @racket['png-bytes], but for an

pkgs/racket-doc/file/scribblings/ico.scrbl

@@ -10,7 +10,8 @@ and writing @filepath{.ico} files, which contain one or more icons.
 Each icon is up to 256 by 256 pixels, has a particular depth (i.e.,
 bits per pixel used to represent a color), and mask (i.e., whether a
 pixel is shown, except that the mask may be ignored for 32-bit icons
-that have an alpha value per pixel).
+that have an alpha value per pixel). The library also provides support
+for reading and writing icons in Windows executables.
 
 @defproc[(ico? [v any/c]) boolean?]{
 
@@ -18,25 +19,40 @@ Returns @racket[#t] if @racket[v] represents an icon, @racket[#f]
 otherwise.}
 
 @deftogether[(
-@defproc[(ico-width [ico ico?]) (integer-in 1 256)]
+@defproc[(ico-width [ico ico?]) exact-positive-integer?]
-@defproc[(ico-height [ico ico?]) (integer-in 1 256)]
+@defproc[(ico-height [ico ico?]) exact-positive-integer?]
 @defproc[(ico-depth [ico ico?]) (one-of/c 1 2 4 8 16 24 32)]
 )]{
 
 Returns the width or height of an icon in pixels, or the depth in bits per
-pixel.}
+pixel.
+
+@history[#:changed "6.3" @elem{A PNG-format icon can have a
+                                      width or height greater than 256.}]}
+
+
+@deftogether[(
+@defproc[(ico-format [ico ico?]) (or/c 'bmp 'png)]
+)]{
+
+Reports the format of the icon.
+
+@history[#:added "6.3"]}
+
 
 @defproc[(read-icos [src (or/c path-string? input-port?)])
          (listof ico?)]{
 
 Parses @racket[src] as an @filepath{.ico} to extract a list of icons.}
 
+
 @defproc[(read-icos-from-exe [src (or/c path-string? input-port?)])
          (listof ico?)]{
 
 Parses @racket[src] as an @filepath{.exe} to extract the list of
 icons that represent the Windows executable.}
 
+
 @defproc[(write-icos [icos (listof ico?)]
                      [dest (or/c path-string? output-port?)]
                      [#:exists exists (or/c 'error 'append 'update 'can-update
@@ -50,22 +66,46 @@ Writes each icon in @racket[icos] to @racket[dest] as an
 @racket[exists] is passed on to @racket[open-output-file] to open
 @racket[dest] for writing.}
 
+
 @defproc[(replace-icos [icos (listof ico?)]
-                       [dest (or/c path-string? output-port?)])
+                       [dest path-string?])
           void?]{
 
 Writes icons in @racket[icos] to replace icons in @racket[dest] as an
 Windows executable. Only existing icon sizes and depths in the
-executable are replaced, and best matches for the existing sizes and
+executable are replaced, and only when the encoding sizes match.
-depth are drawn from @racket[icos] (adjusting the scale and depth f a
+Best matches for the existing sizes and
-best match as necessary).}
+depth are drawn from @racket[icos] (adjusting the scale and depth of a
+best match as necessary).
+
+Use @racket[replace-all-icos], instead, to replace a set of icons
+wholesale, especially when the set include PNG-format icons.}
+
+
+@defproc[(replace-all-icos [icos (listof ico?)]
+                           [dest (or/c path-string? output-port?)])
+          void?]{
+
+Replaces the icon set in the executable @racket[dest] with the given
+set of icons.}
+
 
 @defproc[(ico->argb [ico ico?]) bytes?]{
 
-Converts an icon to an ARGB byte string, which has the icon's pixels
+Converts an icon in BMP format (see @racket[ico-format])
+to an ARGB byte string, which has the icon's pixels
 in left-to-right, top-to-bottom order, with four bytes (alpha, red,
 green, and blue channels) for each pixel.}
 
+
+@defproc[(ico->png-bytes [ico ico?]) bytes?]{
+
+Returns the bytes of a PNG encoding for an icon in PNG format (see
+@racket[ico-format]).
+
+@history[#:added "6.3"]}
+
+
 @defproc[(argb->ico [width (integer-in 1 256)]
                     [height (integer-in 1 256)]
                     [bstr bytes?]
@@ -73,7 +113,16 @@ green, and blue channels) for each pixel.}
          ico?]{
 
 Converts an ARGB byte string (in the same format as from
-@racket[ico->argb]) to an icon of the given width, height, and depth.
+@racket[ico->argb]) to an icon of the given width, height, and depth
+in BMP format.
 
 The @racket[bstr] argument must have a length @racket[(* 4 width height)],
 and @racket[(* width depth)] must be a multiple of 8.}
+
+
+@defproc[(png-bytes->ico [bstr bytes?])
+         ico?]{
+
+Wraps the given PNG encoding as a PNG-encoded icon.
+
+@history[#:added "6.3"]}

pkgs/racket-doc/file/scribblings/tar.scrbl

@@ -11,14 +11,16 @@ directories, files, and symbolic links, and owner
 information is not preserved; the owner that is stored in the archive
 is always ``root.''
 
-Symbolic links (on Unix and Mac OS X) are not followed, and the path
+Symbolic links (on Unix and Mac OS X) are not followed by default, and the path
 in a link must be less than 100 bytes.}
 
 
 @defproc[(tar [tar-file path-string?]
               [path path-string?] ...
+              [#:follow-links? follow-links? any/c #f]
               [#:exists-ok? exists-ok? any/c #f]
               [#:path-prefix path-prefix (or/c #f path-string?) #f]
+              [#:path-filter path-filter (or/c #f (path? . -> . any/c)) #f]
               [#:get-timestamp get-timestamp
                                (path? . -> . exact-integer?)
                                (if timestamp
@@ -32,7 +34,8 @@ relative paths for existing directories and files (i.e., relative
 to the current directory).  If a nested path is provided as a
 @racket[path], its ancestor directories are also added to the
 resulting tar file, up to the current directory (using
-@racket[pathlist-closure]).
+@racket[pathlist-closure]). If @racket[follow-links?] is false, then
+symbolic links are included in the resulting tar file as links.
 
 If @racket[exists-ok?] is @racket[#f], then an exception is raised if
 @racket[tar-file] exists already. If @racket[exists-ok?] is true, then
@@ -45,12 +48,16 @@ The @racket[get-timestamp] function is used to obtain the modification
 date to record in the archive for each file or directory.
 
 @history[#:changed "6.0.0.3" @elem{Added the @racket[#:get-timestamp] argument.}
-         #:changed "6.1.1.1" @elem{Added the @racket[#:exists-ok?] argument.}]}
+         #:changed "6.1.1.1" @elem{Added the @racket[#:exists-ok?] argument.}
+         #:changed "6.3.0.3" @elem{Added the @racket[#:follow-links?] argument.}
+         #:changed "6.3.0.11" @elem{Added the @racket[#:path-filter] argument.}]}
 
 
 @defproc[(tar->output [paths (listof path?)]
                       [out output-port? (current-output-port)]
+                      [#:follow-links? follow-links? any/c #f]
                       [#:path-prefix path-prefix (or/c #f path-string?) #f]
+                      [#:path-filter path-filter (or/c #f (path? . -> . any/c)) #f]
                       [#:get-timestamp get-timestamp
                                        (path? . -> . exact-integer?)
                                        (if timestamp
@@ -64,11 +71,14 @@ archive that is written directly to the @racket[out].  The specified
 content is not automatically added, and nested directories are added
 without parent directories.
 
-@history[#:changed "6.0.0.3" @elem{Added the @racket[#:get-timestamp] argument.}]}
+@history[#:changed "6.0.0.3" @elem{Added the @racket[#:get-timestamp] argument.}
+         #:changed "6.3.0.3" @elem{Added the @racket[#:follow-links?] argument.}
+         #:changed "6.3.0.11" @elem{Added the @racket[#:path-filter] argument.}]}
 
 
 @defproc[(tar-gzip [tar-file path-string?]
                    [paths path-string?] ...
+                   [#:follow-links? follow-links? any/c #f]
                    [#:exists-ok? exists-ok? any/c #f]
                    [#:path-prefix path-prefix (or/c #f path-string?) #f]
                    [#:get-timestamp get-timestamp
@@ -81,4 +91,5 @@ without parent directories.
 Like @racket[tar], but compresses the resulting file with @racket[gzip].
 
 @history[#:changed "6.0.0.3" @elem{Added the @racket[#:get-timestamp] argument.}
-         #:changed "6.1.1.1" @elem{Added the @racket[#:exists-ok?] argument.}]}
+         #:changed "6.1.1.1" @elem{Added the @racket[#:exists-ok?] argument.}
+         #:changed "6.3.0.3" @elem{Added the @racket[#:follow-links?] argument.}]}

pkgs/racket-doc/file/scribblings/untar.scrbl

@@ -9,6 +9,7 @@ a function to extract items from a TAR/USTAR archive.}
 @defproc[(untar           [in (or/c path-string? input-port?)]
                           [#:dest dest-path (or/c path-string? #f) #f]
                           [#:strip-count strip-count exact-nonnegative-integer? 0]
+                          [#:permissive? permissive? any/c #f]
                           [#:filter filter-proc
                                     (path? (or/c path? #f)
                                      symbol? exact-integer? (or/c path? #f)
@@ -28,6 +29,12 @@ elements are removed from the item path from the archive (before
 prefixing the path with @racket[dest-path]); if the item's path
 contains @racket[strip-count] elements, then it is not extracted.
 
+Unless @racket[permissive?] is true, then archive items with paths containing
+an up-directory indicator are disallowed, and a link item whose target
+is an absolute path or contains an up-directory indicator is also
+disallowed. Absolute paths are always disallowed. A disallowed
+path triggers an exception.
+
 For each item in the archive, @racket[filter-proc] is applied to
 
 @itemlist[
@@ -60,4 +67,6 @@ For each item in the archive, @racket[filter-proc] is applied to
 ]
 
 If the result of @racket[filter-proc] is @racket[#f], then the item is
-not unpacked.}
+not unpacked.
+
+@history[#:changed "6.3" @elem{Added the @racket[#:permissive?] argument.}]}

pkgs/racket-doc/file/scribblings/untgz.scrbl

@@ -11,6 +11,7 @@ a function to extract items from a possible @exec{gzip}ped TAR/USTAR archive.}
 @defproc[(untgz           [in (or/c path-string? input-port?)]
                           [#:dest dest-path (or/c path-string? #f) #f]
                           [#:strip-count strip-count exact-nonnegative-integer? 0]
+                          [#:permissive? permissive? any/c #f]
                           [#:filter filter-proc
                                     (path? (or/c path? #f)
                                      symbol? exact-integer? (or/c path? #f)
@@ -21,4 +22,6 @@ a function to extract items from a possible @exec{gzip}ped TAR/USTAR archive.}
          void?]{
 
 The same as @racket[untar], but if @racket[in] is in @exec{gzip} form,
-it is @racket[gunzip]ped as it is unpacked.}
+it is @racket[gunzip]ped as it is unpacked.
+
+@history[#:changed "6.3" @elem{Added the @racket[#:permissive?] argument.}]}

pkgs/racket-doc/file/scribblings/unzip.scrbl

@@ -50,6 +50,7 @@ directory while returning the result of @racket[proc].
 @defproc[(make-filesystem-entry-reader
           [#:dest dest-path (or/c path-string? #f) #f]
           [#:strip-count strip-count exact-nonnegative-integer? 0]
+          [#:permissive? permissive? any/c #f]
           [#:exists exists (or/c 'skip 'error 'replace 'truncate 
                                  'truncate/replace 'append 'update
                                  'can-update 'must-truncate)
@@ -72,13 +73,21 @@ elements are removed from the entry path from the archive (before
 prefixing the path with @racket[dest-path]); if the item's path
 contains @racket[strip-count] elements, then it is not extracted.
 
+Unless @racket[permissive?] is true, then entries with paths containing
+an up-directory indicator are disallowed, and a link entry whose target
+is an absolute path or contains an up-directory indicator is also
+disallowed. Absolute paths are always disallowed. A disallowed
+path triggers an exception.
+
 If @racket[exists] is @racket['skip] and the file for an entry already
 exists, then the entry is skipped. Otherwise, @racket[exists] is
 passed on to @racket[open-output-file] for writing the entry's
 inflated content.
 
 @history[#:changed "6.0.0.3"
-         @elem{Added support for the optional timestamp argument in the result function.}]}
+         @elem{Added support for the optional timestamp argument in the result function.}
+         #:changed "6.3"
+         @elem{Added the @racket[#:permissive?] argument.}]}
 
 
 @defproc[(read-zip-directory [in (or/c path-string? input-port?)]) zip-directory?]{

pkgs/racket-doc/info.rkt

@@ -6,7 +6,7 @@
                "base"
                "net-lib"
                "sandbox-lib"
-               "scribble-lib"
+               ["scribble-lib" #:version "1.14"]
                "racket-index"))
 (define build-deps '("rackunit-doc"
                      "compatibility"

pkgs/racket-doc/openssl/openssl.scrbl

@@ -4,7 +4,10 @@
           (for-label openssl
                      racket
                      openssl/sha1
-                     openssl/md5))
+                     openssl/md5
+                     openssl/libcrypto
+                     openssl/libssl
+                     (only-in ffi/unsafe ffi-lib ffi-lib?)))
 
 @title{OpenSSL: Secure Communication}
 
@@ -26,8 +29,10 @@ or with the Racket distribution. In particular:
 included in the Racket distribution for Windows.}
 
 @item{For Mac OS X, @racketmodname[openssl] depends on
-@filepath{libssl.dylib} and @filepath{libcrypto.dylib}, which are
+@filepath{libssl.dylib} and @filepath{libcrypto.dylib}. Although those
-provided by Mac OS X 10.2 and later.}
+libraries are provided by Mac OS X 10.2 and later, their use is
+deprecated, so the Racket distribution for Mac OS X includes newer
+versions.}
 
 @item{For Unix, @racketmodname[openssl] depends on
 @filepath{libssl.so} and @filepath{libcrypto.so}, which must be
@@ -63,7 +68,9 @@ using the functions described in @secref["cert-procs"].
                       [port-no (integer-in 1 65535)]
                       [client-protocol
                        (or/c ssl-client-context?
-                             'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+                             'secure
+                             'auto
+                             'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
                        'auto])
          (values input-port? output-port?)]{
 
@@ -72,6 +79,10 @@ Connect to the host given by @racket[hostname], on the port given by
 return values are as for @racket[tcp-connect]: an input port and an
 output port.
 
+The default @racket['auto] protocol is @bold{insecure}. Use
+@racket['secure] for a secure connection. See
+@racket[ssl-secure-client-context] for details.
+
 The optional @racket[client-protocol] argument determines which
 encryption protocol is used, whether the server's certificate is
 checked, etc. The argument can be either a client context created by
@@ -101,14 +112,16 @@ well-defined communication pattern, where theres no question of
 whether the other end is supposed to be sending or reading data.
 }
 
-}
+@history[#:changed "6.3.0.12" @elem{Added @racket['secure] for
+                                    @racket[client-protocol].}]}
 
 @defproc[(ssl-connect/enable-break
           [hostname string?]
 	  [port-no (integer-in 1 65535)]
 	  [client-protocol
 	   (or/c ssl-client-context?
-                 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+                 'secure 'auto
+                 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
            'auto])
          (values input-port? output-port?)]{
 
@@ -146,11 +159,13 @@ The context is cached, so different calls to
 
 
 @defproc[(ssl-make-client-context
-          [protocol (or/c 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12) 'auto])
+          [protocol (or/c 'secure 'auto
+                          'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+                    'auto])
          ssl-client-context?]{
 
 Creates a context to be supplied to @racket[ssl-connect]. The context
-is @bold{insecure} unless additional steps are taken; see
+is @bold{insecure} unless @racket['secure] is supplied or additional steps are taken; see
 @racket[ssl-secure-client-context] for details.
 
 The client context identifies a communication protocol (as selected by
@@ -161,6 +176,7 @@ certificates.
 
 The @racket[protocol] should be one of the following:
 @itemize[
+@item{@racket['secure] : Equivalent to @racket[(ssl-secure-client-context)].}
 @item{@racket['auto] : Automatically negotiates the protocol version
 from those that this library considers sufficiently secure---currently
 TLS versions 1.0 and higher, but subject to change.}
@@ -179,27 +195,29 @@ Note that SSL 2.0 support has been removed from many platforms.}
 ]
 
 Not all protocol versions are supported by all servers. The
-@racket['auto] option offers broad compatibility at a reasonable level
+@racket['secure] and @racket['auto] options offer broad compatibility at a reasonable level
 of security. Note that the security of connections depends on more
 than the protocol version; see @racket[ssl-secure-client-context] for
-details.
+details. See also
-
-Not all protocol versions are available on all platforms. See also
 @racket[supported-client-protocols] and
 @racket[supported-server-protocols].
 
 @history[
 #:changed "6.1" @elem{Added @racket['tls11] and @racket['tls12].}
 #:changed "6.1.1.3" @elem{Default to new @racket['auto] and disabled SSL
-2.0 and 3.0 by default.}
+                          2.0 and 3.0 by default.}
+#:changed "6.3.0.12" @elem{Added @racket['secure].}
 ]}
 
 
 @defproc[(supported-client-protocols)
-         (listof (or/c 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12))]{
+         (listof (or/c 'secure 'auto
+                       'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12))]{
 
 Returns a list of symbols representing protocols that are supported
-for clients on the current platform.}
+for clients on the current platform.
+
+@history[#:changed "6.3.0.12" @elem{Added @racket['secure].}]}
 
 
 @defproc[(ssl-client-context? [v any/c]) boolean?]{
@@ -209,7 +227,7 @@ Returns @racket[#t] if @racket[v] is a value produced by
 
 @history[#:added "6.0.1.3"]}
 
-@defproc[(ssl-max-client-protocol) (or/c 'sslv2 sslv3 'tls 'tls11 'tls12 #f)]{
+@defproc[(ssl-max-client-protocol) (or/c 'sslv2 'sslv3 'tls 'tls11 'tls12 #f)]{
 
 Returns the most recent SSL/TLS protocol version supported by the
 current platform for client connections.
@@ -228,13 +246,15 @@ current platform for client connections.
 	  [hostname-or-#f (or/c string? #f) #f]
 	  [server-protocol
 	   (or/c ssl-server-context? 
-                 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+                 'secure 'auto
+                 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
            'auto])
 	 ssl-listener?]{
 
 Like @racket[tcp-listen], but the result is an SSL listener. The extra optional
 @racket[server-protocol] is as for @racket[ssl-connect], except that a
-context must be a server context instead of a client context.
+context must be a server context instead of a client context, and
+@racket['secure] is simply an alias for @racket['auto].
 
 Call @racket[ssl-load-certificate-chain!] and
 @racket[ssl-load-private-key!] to avoid a @emph{no shared cipher}
@@ -247,7 +267,9 @@ An SSL listener is a synchronizable value (see @racket[sync]). It is
 ready---with itself as its value---when the underlying TCP listener is
 ready. At that point, however, accepting a connection with
 @racket[ssl-accept] may not complete immediately, because
-further communication is needed to establish the connection.}
+further communication is needed to establish the connection.
+
+@history[#:changed "6.3.0.12" @elem{Added @racket['secure].}]}
 
 
 @deftogether[(
@@ -295,11 +317,16 @@ Returns @racket[#t] of @racket[v] is an SSL port produced by
 
 
 @defproc[(ssl-make-server-context
-          [protocol (or/c 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+          [protocol (or/c 'secure 'auto
+                          'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
                     'auto])
          ssl-server-context?]{
 
-Like @racket[ssl-make-client-context], but creates a server context.}
+Like @racket[ssl-make-client-context], but creates a server context.
+For a server context, the @racket['secure] protocol is the same as
+@racket['auto].
+
+@history[#:changed "6.3.0.12" @elem{Added @racket['secure].}]}
 
 
 @defproc[(ssl-server-context? [v any/c]) boolean?]{
@@ -308,14 +335,16 @@ Returns @racket[#t] if @racket[v] is a value produced by
 @racket[ssl-make-server-context], @racket[#f] otherwise.}
 
 @defproc[(supported-server-protocols)
-         (listof (or/c 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12))]{
+         (listof (or/c 'secure 'auto
+                       'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12))]{
 
 Returns a list of symbols representing protocols that are supported
 for servers on the current platform.
 
-@history[#:added "6.0.1.3"]}
+@history[#:added "6.0.1.3"
+         #:changed "6.3.0.12" @elem{Added @racket['secure].}]}
 
-@defproc[(ssl-max-server-protocol) (or/c 'sslv2 sslv3 'tls 'tls11 'tls12 #f)]{
+@defproc[(ssl-max-server-protocol) (or/c 'sslv2 'sslv3 'tls 'tls11 'tls12 #f)]{
 
 Returns the most recent SSL/TLS protocol version supported by the
 current platform for server connections.
@@ -337,7 +366,8 @@ current platform for server connections.
                            ssl-make-server-context 
                            ssl-make-client-context)
                        protocol)]
-	   [#:encrypt protocol (or/c 'auto 'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
+	   [#:encrypt protocol (or/c 'secure 'auto
+                                     'sslv2-or-v3 'sslv2 'sslv3 'tls 'tls11 'tls12)
                       'auto]
 	   [#:close-original? close-original? boolean? #f]
 	   [#:shutdown-on-close? shutdown-on-close? boolean? #f]
@@ -820,3 +850,58 @@ The @racket[md5] function composes @racket[bytes->hex-string] with
 Returns a 16-byte byte string that represents the MD5 hash of the
 content from @racket[in], consuming all of the input from @racket[in]
 until an end-of-file.}
+
+@; ----------------------------------------------------------------------
+
+@(define foreign-doc '(lib "scribblings/foreign/foreign.scrbl"))
+
+@section[#:tag "libcrypto"]{The @filepath{libcrypto} Shared Library}
+
+@defmodule[openssl/libcrypto]{The @racketmodname[openssl/libcrypto]
+library provides a @tech[#:doc foreign-doc]{foreign-library value} for
+the @filepath{libcrypto} shared library.}
+
+
+@defthing[libcrypto (or/c #f ffi-lib?)]{
+
+Returns a @tech[#:doc foreign-doc]{foreign-library value} for
+@filepath{libcrypto}, or @racket[#f] if the library could not be found
+or loaded. The load attempt uses the versions specified by
+@racket[openssl-lib-versions].}
+
+@defthing[libcrypto-load-fail-reason (or/c #f string?)]{
+
+Either @racket[#f] when @racket[libcrypto] is non-@racket[#f], or a
+string when @racket[libcrypto] is @racket[#f]. In the latter case, the
+string provides an error message for the attempt to load
+@filepath{libcrypto}.}
+
+
+@defthing[openssl-lib-versions (listof string?)]{
+
+A list of versions that are tried for loading @filepath{libcrypto}.
+The list of version strings is suitable as a second argument to
+@racket[ffi-lib].}
+
+@; ----------------------------------------------------------------------
+
+@section[#:tag "libssl"]{The @filepath{libssl} Shared Library}
+
+@defmodule[openssl/libssl]{The @racketmodname[openssl/libssl]
+library provides a @tech[#:doc foreign-doc]{foreign-library value} for
+the @filepath{libssl} shared library.}
+
+
+@defthing[libssl (or/c #f ffi-lib?)]{
+
+Returns a @tech[#:doc foreign-doc]{foreign-library value} for
+@filepath{libssl}, or @racket[#f] if the library could not be found
+or loaded. The load attempt uses the versions specified by
+@racket[openssl-lib-versions].}
+
+@defthing[libssl-load-fail-reason (or/c #f string?)]{
+
+Either @racket[#f] when @racket[libssl] is non-@racket[#f], or a
+string when @racket[libssl] is @racket[#f]. In the latter case, the
+string provides an error message for the attempt to load
+@filepath{libssl}.}

pkgs/racket-doc/pkg/scribblings/apis.scrbl

@@ -53,3 +53,4 @@ to the @exec{raco pkg} sub-subcommands.
 @include-section["name.scrbl"]
 @include-section["db.scrbl"]
 @include-section["dirs-catalog.scrbl"]
+@include-section["envvars.scrbl"]

pkgs/racket-doc/pkg/scribblings/catalog-protocol.scrbl

@@ -33,7 +33,7 @@ information about packages:
        @exec{version=}@nonterm{version} query (where @nonterm{version}
        is a Racket version number) in the case of a remote URL.
 
-       This URL/path form is use to obtain information about
+       This URL/path form is used to obtain information about
        @nonterm{package}. An HTTP request for a remote URL should
        respond with a @racket[read]-able hash table, as described
        below. A path in a local directory formed by adding
@@ -130,7 +130,8 @@ information about packages:
 
 Note that a local directory served as files through an HTTP server
 works as a remote URL, as long as the @filepath{pkgs} and
-@filepath{pkgs-all} files are present.
+@filepath{pkgs-all} files are present (since those are optional for
+local but required for HTTP).
 
 The source for the PLT-hosted @tech{package catalog} is in the
 @racket[(collection-file-path "pkg-catalog" "meta")]

pkgs/racket-doc/pkg/scribblings/envvars.scrbl

@@ -0,0 +1,14 @@
+#lang scribble/manual
+@(require "common.rkt")
+
+@title[#:tag "envvars"]{Package Management Environment Variables}
+
+If the @indexed-envvar{PLT_PKG_SSL_NO_VERIFY} environment variable is
+set, server certificates are not validated for HTTPS connections. When
+accessing Git servers over HTTPS, @envvar{GIT_SSL_NO_VERIFY} must be
+set, too, to disable certificate validation.
+
+As noted in the specification of GitHub-repository package sources, if
+the @envvar{PLT_USE_GITHUB_API} environment variable is set, GitHub
+packages are obtained using the GitHub API protocol instead of using
+the Git protocol.

pkgs/racket-doc/pkg/scribblings/getting-started.scrbl

@@ -131,7 +131,7 @@ treated as a explicitly installed package.
 
 The PLT @tech{package catalog} at
 
-@centerline{@url{http://pkgs.racket-lang.org}}
+@centerline{@url{https://pkgs.racket-lang.org}}
 
 provides a centralized listing of available Racket packages. The PLT
 @tech{package catalog} normally will be the first place you check when
@@ -385,7 +385,9 @@ is:
 
 If you want the package to be @nonterm{branch} or @nonterm{tag}
 instead of @exec{master}, then add @filepath{#@nonterm{branch}} or
-@filepath{#@nonterm{tag}} to the end of the package source.
+@filepath{#@nonterm{tag}} to the end of the package source. If your
+package is a subdirectory @nonterm{path} within the repository, add
+@filepath{?path=@nonterm{path}} to the end of the package source.
 
 Whenever you
 
@@ -395,9 +397,10 @@ your changes will automatically be discovered by those who use
 @command-ref{update} after installing from your
 GitHub-based @tech{package source}.
 
-As of Racket version 6.1.1.1, other Git repository services can work
+Other Git repository services@margin-note*{Support for services other
+than GitHub requires Racket version 6.1.1.1 or later.} can work
 just as well as GitHub---including Gitorious or BitBucket---as long as
-the server supports either the ``smart'' HTTP(S) protocol or the
+the server supports either the HTTP(S) protocol or the
 native Git protocol (but use a @exec{git://} path for the latter).
 
 The Racket package manager provides more support for Git-based
@@ -445,7 +448,7 @@ by a simple name until it is listed on a @tech{package catalog}.
 
 If you'd like to use the PLT @tech{package catalog}, browse
 to
-@link["http://pkgs.racket-lang.org/"]{http://pkgs.racket-lang.org/}
+@link["https://pkgs.racket-lang.org/"]{https://pkgs.racket-lang.org/}
 and upload a new package. You will need to create an account and log
 in first.
 
@@ -558,7 +561,7 @@ In your @racket[info.rkt], you should:
 ]
 
 Finally, when listing your package on
-@url{http://pkgs.racket-lang-org}, you should supply a GitHub source
+@url{https://pkgs.racket-lang-org}, you should supply a GitHub source
 using the URL format
 @tt{github://github.com/@nonterm{user}/@nonterm{repo}/@nonterm{rev}@optional{/@nonterm{path}}} (not
 the @tt{git://} or @exec{http://} format).

pkgs/racket-doc/pkg/scribblings/git-workflow.scrbl

@@ -102,7 +102,7 @@ develops only a few of them. The intended workflow is as follows:
 
   @commandline{@command{update} --lookup --catalog @nonterm{catalog} --clone @nonterm{path-to}/@nonterm{pkg-name}}
 
-  A suitable @nonterm{catalog} might be @url{http://pkgs.racket-lang.org}.}
+  A suitable @nonterm{catalog} might be @url{https://pkgs.racket-lang.org}.}
 
  @item{A newly cloned package will have the specified (or existing
   installation's) repository as its Git @exec{origin}. If you want to

pkgs/racket-doc/pkg/scribblings/lib.scrbl

@@ -103,6 +103,18 @@ used.
 @history[#:added "6.1.1.6"]}
 
 
+@deftogether[(
+@defparam[current-pkg-network-retries max-retries (or/c #f real?)]
+)]{
+
+A parameter that determines the number of times to retry a network communication
+that fails due to a connection error.  If
+a parameter's value is @racket[#f], then the user's configuration is
+used.
+
+@history[#:added "6.3"]}
+
+
 @defproc[(pkg-directory [name string?]
                         [#:cache cache (or/c #f (and/c hash? (not/c immutable?))) #f])
          (or/c path-string? #f)]{
@@ -161,7 +173,7 @@ the package is should be treated as installed automatically for a
 dependency.
 
 The optional @racket[path] argument is intended for use when
-@racket[type] is @racket['clone], in which case it specifies< a
+@racket[type] is @racket['clone], in which case it specifies a
 directory containing the repository clone (where the repository itself
 is a directory within @racket[path]).
 
@@ -253,7 +265,8 @@ is true, error messages may suggest specific command-line flags for
                            [#:force-strip? force-string? boolean? #f]
                            [#:multi-clone-mode multi-clone-mode (or/c 'fail 'force 'convert 'ask) 'fail]
                            [#:pull-mode pull-mode (or/c 'ff-only 'try 'rebase) 'ff-only]
-                           [#:link-dirs? link-dirs? boolean? #f])
+                           [#:link-dirs? link-dirs? boolean? #f]
+                           [#:dry-run? dry-run? boolean? #f])
          (or/c 'skip
                #f
                (listof (or/c path-string?
@@ -287,7 +300,8 @@ The package lock must be held; see @racket[with-pkg-lock].
 @history[#:changed "6.1.1.5" @elem{Added the @racket[#:multi-clone-mode] 
                                    and @racket[#:infer-clone-from-dir?] arguments.}
          #:changed "6.1.1.6" @elem{Added the @racket[#:use-trash?] argument.}
-         #:changed "6.1.1.8" @elem{Added the @racket[#:pull-mode] argument.}]}
+         #:changed "6.1.1.8" @elem{Added the @racket[#:pull-mode] argument.}
+         #:changed "6.4.0.14" @elem{Added the @racket[#:dry-run] argument.}]}
 
 
 @defproc[(pkg-update      [sources (listof (or/c string? pkg-desc?))]
@@ -302,7 +316,7 @@ The package lock must be held; see @racket[with-pkg-lock].
                           [#:use-cache? use-cache? boolean? #t]
                           [#:skip-uninstalled? skip-uninstalled? boolean? #t]
                           [#:quiet? quiet? boolean? #f]
-                          [#:use-trash? boolean? use-trash? #f]
+                          [#:use-trash? use-trash? boolean? #f]
                           [#:from-command-line? from-command-line? boolean? #f]
                           [#:strip strip (or/c #f 'source 'binary 'binary-lib) #f]
                           [#:force-strip? force-string? boolean? #f]
@@ -310,7 +324,8 @@ The package lock must be held; see @racket[with-pkg-lock].
                           [#:multi-clone-mode multi-clone-mode (or/c 'fail 'force 'convert 'ask) 'fail]
                           [#:pull-mode pull-mode (or/c 'ff-only 'try 'rebase) 'ff-only]
                           [#:link-dirs? link-dirs? boolean? #f]
-                          [#:infer-clone-from-dir? infer-clone-from-dir? boolean? #f])
+                          [#:infer-clone-from-dir? infer-clone-from-dir? boolean? #f]
+                          [#:dry-run? dry-run? boolean? #f])
         (or/c 'skip
               #f
               (listof (or/c path-string?
@@ -345,7 +360,8 @@ The package lock must be held; see @racket[with-pkg-lock].
 @history[#:changed "6.1.1.5" @elem{Added the @racket[#:multi-clone-mode] 
                                    and @racket[#:infer-clone-from-dir?] arguments.}
          #:changed "6.1.1.6" @elem{Added the @racket[#:use-trash?] argument.}
-         #:changed "6.1.1.8" @elem{Added the @racket[#:skip-uninstalled?] and @racket[#:pull-mode] arguments.}]}
+         #:changed "6.1.1.8" @elem{Added the @racket[#:skip-uninstalled?] and @racket[#:pull-mode] arguments.}
+         #:changed "6.4.0.14" @elem{Added the @racket[#:dry-run] argument.}]}
 
 
 @defproc[(pkg-remove      [names (listof string?)]
@@ -354,7 +370,8 @@ The package lock must be held; see @racket[with-pkg-lock].
                           [#:force? force? boolean? #f]
                           [#:quiet? quiet? boolean? #f]
                           [#:use-trash? boolean? use-trash? #f]
-                          [#:from-command-line? from-command-line? boolean? #f])
+                          [#:from-command-line? from-command-line? boolean? #f]
+                          [#:dry-run? dry-run? boolean? #f])
          (or/c 'skip
                #f
                (listof (or/c path-string? 
@@ -369,7 +386,8 @@ specific command-line flags for @command-ref{remove}.
 
 The package lock must be held; see @racket[with-pkg-lock].
 
-@history[#:changed "6.1.1.6" @elem{Added the @racket[#:use-trash?] argument.}]}
+@history[#:changed "6.1.1.6" @elem{Added the @racket[#:use-trash?] argument.}
+         #:changed "6.4.0.14" @elem{Added the @racket[#:dry-run] argument.}]}
 
 
 @defproc[(pkg-new [name path-string?])
@@ -407,7 +425,8 @@ The package lock must be held to allow reads; see
                            [#:quiet? quiet? boolean? #f]
                            [#:from-command-line? from-command-line? boolean? #f]
                            [#:strip strip (or/c #f 'source 'binary 'binary-lib) #f]
-                           [#:force-strip? force-string? boolean? #f])
+                           [#:force-strip? force-string? boolean? #f]
+                           [#:dry-run? dry-run? boolean? #f])
          (or/c 'skip
                #f
                (listof (or/c path-string?
@@ -419,7 +438,9 @@ Implements @racket[pkg-migrate-command].  The result is the same as for
 If @racket[from-command-line?]  is true, error messages may suggest
 specific command-line flags for @command-ref{migrate}.
 
-The package lock must be held; see @racket[with-pkg-lock].}
+The package lock must be held; see @racket[with-pkg-lock].
+
+@history[#:changed "6.4.0.14" @elem{Added the @racket[#:dry-run] argument.}]}
 
 
 @defproc[(pkg-catalog-show [names (listof string?)]
@@ -678,7 +699,7 @@ represented by @racket[dir] and named @racket[pkg-name].}
                                              [pkg-name string]
                                              [#:namespace namespace namespace? (make-base-namespace)]
                                              [#:system-type sys-type (or/c #f symbol?) (system-type)]
-                                             [#:system-library-subpath sys-lib-subpath (or/c #f path?)
+                                             [#:system-library-subpath sys-lib-subpath (or/c #f path-for-some-system?)
                                                                        (system-library-subpath #f)])
          (listof (cons/c symbol? string?))]{
 

pkgs/racket-doc/pkg/scribblings/pkg.scrbl

@@ -173,8 +173,8 @@ For example,
 
 A package source is inferred to refer
 to a directory only when it does not have a file-archive suffix, does
-not match the grammar of a package name, and either starts with starts 
+not match the grammar of a package name, and either starts with
-with @litchar{file://} or does not start
+@litchar{file://} or does not start
 with alphabetic characters followed by @litchar{://}.  In the
 case that the package source starts with @litchar{file://},
 it must be a URL without a @litchar{type} query or
@@ -285,8 +285,8 @@ is a GitHub package source.
 @margin-note{A Github repository source that starts with
 @litchar{git://} obtains the same content that would be accessed if
 @litchar{github.com} were not treated specially. The special treatment
-is preserved for historical reasons and because GitHub provides an
+is preserved for historical reasons, especially in combination
-interface that is always efficient.}
+with @envvar{PLT_USE_GITHUB_API}.}
 
 For backward compatibility, an older format is also supported:
 
@@ -304,7 +304,15 @@ with @litchar{git://github.com/} or @litchar{github://}; a package
 source that is otherwise specified as a GitHub reference is
 automatically prefixed with @litchar{git://github.com/}. The inferred
 package name is the last element of @nonterm{path} if it is non-empty,
-otherwise the inferred name is @nonterm{repo}.}
+otherwise the inferred name is @nonterm{repo}.
+
+If the @indexed-envvar{PLT_USE_GITHUB_API} environment variable is
+set, GitHub packages are obtained using the GitHub API protocol
+instead of using the Git protocol.
+
+@history[#:changed "6.3" @elem{Changed handling of
+                                      GitHub sources to use the Git
+                                      protocol by default.}]}
 
 @; ----------------------------------------
 @item{a @tech{package name} --- A @tech{package catalog} is
@@ -329,7 +337,7 @@ URL indicates a remote server, and a @litchar{file://} URL indicates a
 local catalog in the form of an SQLite database or a directory tree.
 
 PLT supports two @tech{package catalog} servers that are enabled by
-default: @url{http://pkgs.racket-lang.org} for new packages and
+default: @url{https://pkgs.racket-lang.org} for new packages and
 @url{http://planet-compats.racket-lang.org} for automatically
 generated packages for old @|PLaneT| packages. Anyone may host a
 @tech{package catalog}, and any file-serving HTTP host can act
@@ -588,6 +596,9 @@ sub-commands.
     ]}
 
 
+  @item{@DFlag{dry-run} --- Prevents changes to the current installation. All installation and update work is
+                            staged and checked, but the final installation step is skipped.}
+
   @item{@DFlag{no-setup} --- Does not run @exec{raco setup} after installation. This behavior is also the case if the
         environment variable @envvar{PLT_PKG_NOSETUP} is set to any non-empty value.}
 
@@ -605,7 +616,8 @@ sub-commands.
                                    @DFlag{multi-clone} flags.}
          #:changed "6.1.1.6" @elem{Added the @DFlag{no-trash} flag, and changed
                                    the @DFlag{deps} default to depend only on interactive mode.}
-         #:changed "6.1.1.8" @elem{Added the @DFlag{pull} flag.}]}
+         #:changed "6.1.1.8" @elem{Added the @DFlag{pull} flag.}
+         #:changed "6.4.0.14" @elem{Added the @DFlag{dry-run} flag.}]}
 
 
 @subcommand{@command/toc{update} @nonterm{option} ... @nonterm{pkg-source} ... 
@@ -715,6 +727,7 @@ the given @nonterm{pkg-source}s.
 
  @item{@DFlag{pull} @nonterm{mode} --- Same as for @command-ref{install}}
 
+ @item{@DFlag{dry-run} --- Same as for @command-ref{install}.}
  @item{@DFlag{no-setup} --- Same as for @command-ref{install}.}
  @item{@DFlag{jobs} @nonterm{n} or @Flag{j} @nonterm{n} --- Same as for @command-ref{install}.}
  @item{@DFlag{batch} --- Same as for @command-ref{install}.}
@@ -727,7 +740,8 @@ the given @nonterm{pkg-source}s.
                                    when no arguments are provided.}
          #:changed "6.1.1.6" @elem{Added the @DFlag{no-trash} flag, and changed
                                    the @DFlag{deps} default to depend only on interactive mode.}
-         #:changed "6.1.1.8" @elem{Added the @DFlag{skip-uninstalled} and @DFlag{pull} flags.}]}
+         #:changed "6.1.1.8" @elem{Added the @DFlag{skip-uninstalled} and @DFlag{pull} flags.}]
+         #:changed "6.4.0.14" @elem{Added the @DFlag{dry-run} flag.}}
 
 @subcommand{@command/toc{remove} @nonterm{option} ... @nonterm{pkg} ... 
 --- Attempts to remove the given packages. By default, if a package is the dependency
@@ -753,6 +767,7 @@ the given @nonterm{pkg}s.
  @item{@Flag{i} or @DFlag{installation} --- Shorthand for @exec{--scope installation}.}
  @item{@Flag{u} or @DFlag{user} --- Shorthand for @exec{--scope user}.}
  @item{@DFlag{scope-dir} @nonterm{dir} --- Selects @nonterm{dir} as the @tech{package scope}, the same as for @command-ref{install}.}
+ @item{@DFlag{dry-run} --- Same as for @command-ref{install}.}
  @item{@DFlag{no-setup} --- Same as for @command-ref{install}.}
  @item{@DFlag{jobs} @nonterm{n} or @Flag{j} @nonterm{n} --- Same as for @command-ref{install}.}
  @item{@DFlag{batch} --- Same as for @command-ref{install}.}
@@ -760,7 +775,8 @@ the given @nonterm{pkg}s.
  ]
 
 @history[#:changed "6.1.1.5" @elem{Added the @DFlag{batch} flag.}
-         #:changed "6.1.1.6" @elem{Added the @DFlag{no-trash} flag.}]}
+         #:changed "6.1.1.6" @elem{Added the @DFlag{no-trash} flag.}
+         #:changed "6.4.0.14" @elem{Added the @DFlag{dry-run} flag.}]}
 
 
 @subcommand{@command/toc{new} @nonterm{pkg} ---
@@ -840,10 +856,12 @@ package is created.
   @item{@DFlag{ignore-checksums} --- Same as for @command-ref{install}.}
   @item{@DFlag{strict-doc-conflicts} --- Same as for @command-ref{install}.}
   @item{@DFlag{no-cache} --- Same as for @command-ref{install}.}
+  @item{@DFlag{dry-run} --- Same as for @command-ref{install}.}
   @item{@DFlag{no-setup} --- Same as for @command-ref{install}.}
   @item{@DFlag{jobs} @nonterm{n} or @Flag{j} @nonterm{n} --- Same as for @command-ref{install}.}
  ]
-}
+
+@history[#:changed "6.4.0.14" @elem{Added the @DFlag{dry-run} flag.}]}
 
 @subcommand{@command/toc{create} @nonterm{option} ... @nonterm{directory-or-package}
 --- Bundles a package into an archive. Bundling
@@ -932,9 +950,12 @@ for @nonterm{key}.
         updated that its implementation is kept in the trash folder. Package implementations are
         removed from a trash folder only when another package is potentially added
         to the trash folder or @command-ref{empty-trash} is used.}
+  @item{@exec{network-retries} --- The number of times to retry a network communication that
+        fails due to a connection error.}
  ]
 
-@history[#:changed "6.1.1.6" @elem{Added @exec{trash-max-packages} and @exec{trash-max-seconds}.}]}
+@history[#:changed "6.1.1.6" @elem{Added @exec{trash-max-packages} and @exec{trash-max-seconds}.}
+         #:changed "6.3" @elem{Added @exec{network-retries}.}]}
 
 
 @subcommand{@command/toc{catalog-show} @nonterm{option} ... @nonterm{package-name} ...
@@ -1015,6 +1036,15 @@ for @nonterm{key}.
  @item{@DFlag{version} @nonterm{version} or @Flag{v} @nonterm{version} --- Copies catalog
        results specific to @nonterm{version}
        (for catalogs that make a distinction), instead of the installation's Racket version.}
+  @item{@DFlag{pkg-fail} @nonterm{mode} --- Determines handling of failure for an individual
+       package, such as when a @nonterm{src-catalog} contains a bad package source. The
+       following @nonterm{mode}s are available:
+       @itemlist[
+         @item{@exec{fail} (the default) --- archiving stops and fails;}
+         @item{@exec{skip} --- the package is skipped and omitted from the archive catalog; or}
+         @item{@exec{continue} --- like @exec{skip}, but @exec{raco pkg catalog-archive}
+               exits with a status code of @exec{5} if any package was skipped.}
+       ]}
  ]
 
  @history[#:added "6.0.17"]
@@ -1406,10 +1436,10 @@ tests, and documentation from a package before installing it.
 site (where a Racket distribution downloaded from the site is
 configured to consult the site for packages), at least for packages
 associated with the distribution. Beware that
-@url{http://pkgs.racket-lang.org/} generally refers to @tech{source
+@url{https://pkgs.racket-lang.org/} generally refers to @tech{source
 packages}, not @tech{built packages}. In the near future, built
-variants of the @url{http://pkgs.racket-lang.org/} packages will be
+variants of the @url{https://pkgs.racket-lang.org/} packages will be
-provided at @url{http://pkg-build.racket-lang.org/catalog/}.
+provided at @url{https://pkg-build.racket-lang.org/catalog/}.
 
 Some packages have been split at the source level into separate
 library, test, and documentation packages. For example,

pkgs/racket-doc/pkg/scribblings/strip.scrbl

@@ -74,7 +74,7 @@ the following files and directories:
 Any of the above can be suppressed, however, by a
 @racket[source-keep-files] (for @tech{source package} and @tech{built
 package} bundling), @racket[binary-keep-files] (for @tech{binary
-package}, @tech{binary library package} @tech{built package} bundling),
+package}, @tech{binary library package} and @tech{built package} bundling),
 or @racket[binary-lib-keep-files] (for @tech{binary library package} bundling) definition in an
 @filepath{info.rkt} in the package or any subdirectory. A
 @racket[source-keep-files], @racket[binary-keep-files], or @racket[binary-lib-keep-files] definition

pkgs/racket-doc/scribblings/foreign/active-x.scrbl

@@ -36,9 +36,11 @@ the ``Sysmon'' ActiveX control that is included with Windows.
                              (lambda (doc url) (semaphore-post ready)) 
                              ex)
 
-;; Navigate to an empty URL to get an initial document:
+;; Navigate to get an initial document:
-(com-invoke ie "Navigate" "")
+(com-invoke ie "Navigate" "about:blank")
-(semaphore-wait ready)
+(define READYSTATE_COMPLETE 4)
+(unless (= (com-get-property ie "READYSTATE") READYSTATE_COMPLETE)
+  (semaphore-wait ready))
 (define doc (com-get-property ie "Document"))
 
 ;; Install HTML to show the ActiveX control:

pkgs/racket-doc/scribblings/foreign/atomic.scrbl

@@ -11,11 +11,17 @@ computation in this sense is @emph{not} atomic with respect to other
 @tech[#:doc reference.scrbl]{places}, but only to other @tech[#:doc
 reference.scrbl]{threads} within a place.
 
-Atomic mode is unsafe, because the Racket scheduler is not able to
+@elemtag["atomic-unsafe"]{Atomic mode is @bold{unsafe}}, because the
-operate while execution is in atomic mode; the scheduler cannot switch
+Racket scheduler is not able to operate while execution is in atomic
-threads or poll certain kinds of events, which can lead to deadlock or
+mode; the scheduler cannot switch threads or poll certain kinds of
-starvation of other threads. Beware that many operations can involve
+events, which can lead to deadlock or starvation of other threads.
-such synchronization, such as writing to an output port.
+Beware that many operations can involve such synchronization, such as
+writing to an output port. Even if an output target is known to be
+free of synchronization, beware that values can have arbitrary
+printing procedures attached through @racket[prop:custom-write].
+Successful use of atomic mode requires a detailed knowledge of any
+implementation that might be reached during atomic mode to ensure that
+it terminates and does not involve synchronization.
 
 @deftogether[(
 @defproc[(start-atomic) void?]
@@ -51,7 +57,9 @@ Using @racket[call-as-atomic] is somewhat safer than using
 exiting atomic mode, and it wraps any call to the error value
 conversion handler with @racket[call-as-nonatomic]. The latter is safe
 for a particular atomic region, however, only if the region can be
-safely interrupted by a non-atomic exception construction.}
+safely interrupted by a non-atomic exception construction.
+
+See also the caveat that @elemref["atomic-unsafe"]{atomic mode is unsafe}.}
 
 
 @deftogether[(
@@ -82,11 +90,7 @@ re-raised after exiting atomic mode. Any call to the current
 @tech[#:doc reference.scrbl]{error value conversion handler} is
 effectively wrapped with @racket[call-as-nonatomic].
 
-Besides obvious paths to unknown expressions that may not be safe for
+See also the caveat that @elemref["atomic-unsafe"]{atomic mode is unsafe}.}
-atomic mode, beware of printing an arbitrary value in any way other
-than the error value conversion handler, because values can have
-arbitrary printing procedures attached through
-@racket[prop:custom-write].}
 
 
 @defproc[(call-as-nonatomic [thunk (-> any)]) any]{

pkgs/racket-doc/scribblings/foreign/com-auto.scrbl

@@ -209,6 +209,14 @@ A constant for use with @racket[com-invoke] in place of an optional
 argument.}
 
 
+@defproc[(com-omit? [v any/c]) boolean?]{
+
+Returns @racket[#t] if @racket[v] is @racket[com-omit], @racket[#f]
+otherwise.
+
+@history[#:added "6.3.0.3"]}
+
+
 @; ----------------------------------------
 
 @section{COM Properties}

pkgs/racket-doc/scribblings/foreign/com.scrbl

@@ -9,7 +9,7 @@
 The @racketmodname[ffi/com] and @racketmodname[ffi/unsafe/com]
 libraries support COM interaction in two layers. The safe upper layer
 provides functions for creating COM objects and dynamically
-constructing method calls based on COM automatiion (i.e., reflective
+constructing method calls based on COM automation (i.e., reflective
 information provided by the object). The unsafe lower layer provides a
 syntactic form and functions for working more directly with COM
 objects and interfaces.

pkgs/racket-doc/scribblings/foreign/define.scrbl

@@ -23,8 +23,8 @@ the library produced by @racket[ffi-lib-expr]. The syntax of
                              (code:line #:fail fail-expr)])]
 
 A @racket[define-id] form binds @racket[id] by extracting a binding
-with the name @racket[c-id] from the library produced by
+with the name @racket[_c-id] from the library produced by
-@racket[ffi-lib-expr], where @racket[c-id] defaults to @racket[id].
+@racket[ffi-lib-expr], where @racket[_c-id] defaults to @racket[_id].
 The other options support further wrapping and configuration:
 
 @itemize[

pkgs/racket-doc/scribblings/foreign/misc.scrbl

@@ -26,11 +26,16 @@ internal representation of @racket[vec].}
 Returns a pointer to an array of @racket[_double] values, which is the
 internal representation of @racket[flvec].}
 
-@defproc[(saved-errno) exact-integer?]{
+@defproc*[([(saved-errno) exact-integer?]
+           [(saved-errno [new-value exact-integer?]) void?])]{
 
-Returns the value most recently saved (in the current thread) after a
+Returns or sets the error code saved for the current Racket
-foreign call with a non-@racket[#f] @racket[#:save-errno] option (see
+thread. The saved error code is set after a foreign call with a
-@racket[_fun] and @racket[_cprocedure]).}
+non-@racket[#f] @racket[#:save-errno] option (see @racket[_fun] and
+@racket[_cprocedure]), but it can also be set explicitly (for example,
+to create mock foreign functions for testing).
+
+@history[#:changed "6.4.0.9"]{Added the one-argument variant.}}
 
 @defproc[(lookup-errno [sym (or/c 'EINTR 'EEXIST 'EAGAIN)])
          exact-integer?]{

pkgs/racket-doc/scribblings/foreign/objc.scrbl

@@ -269,6 +269,56 @@ Check whether @racket[subcls] is @racket[cls] or a subclass.
 
 @history[#:added "6.1.0.5"]}
 
+
+@defproc[(objc-get-class [obj _id]) _Class]{
+
+Extract the class of @racket[obj].
+
+@history[#:added "6.3"]}
+
+
+@defproc[(objc-set-class! [obj _id] [cls _Class]) void?]{
+
+Changes the class of @racket[obj] to @racket[cls]. The object's
+existing representation must be compatible with the new class.
+
+@history[#:added "6.3"]}
+
+
+@defproc[(objc-get-superclass [cls _Class]) _Class]{
+
+Returns the superclass of @racket[cls].
+
+@history[#:added "6.3"]}
+
+
+@defproc[(objc-dispose-class [cls _Class]) void?]{
+
+Destroys @racket[cls], which must have no existing instances or
+subclasses.
+
+@history[#:added "6.3"]}
+
+
+@defproc[(objc-block [function-type? ctype]
+                     [proc procedure?]
+                     [#:keep keep (box/c list?)])
+         cpointer?]{
+
+Wraps a Racket function @racket[proc] as an Objective-C block. The
+procedure must accept an initial pointer argument that is the ``self''
+argument for the block, and that extra argument must be included in
+the given @racket[function-type].
+
+Extra records that are allocated to implement the block are added to
+the list in @racket[keep], which might also be included in
+@racket[function-type] through a @racket[#:keep] option to
+@racket[_fun]. The pointers registered in @racket[keep] must be
+retained as long as the block remains in use.
+
+@history[#:added "6.3"]}
+
+
 @; ----------------------------------------------------------------------
 
 @section{Raw Runtime Functions}

pkgs/racket-doc/scribblings/foreign/pointers.scrbl

@@ -233,7 +233,7 @@ see @|InsideRacket|.
                                       ctype?) 
                                 @#,elem{absent}]
                  [cptr cpointer? @#,elem{absent}]
-                 [mode (one-of/c 'raw 'atomic 'nonatomic
+                 [mode (one-of/c 'raw 'atomic 'nonatomic 'tagged
                                  'atomic-interior 'interior
                                  'stubborn 'uncollectable 'eternal)
                        @#,elem{absent}]
@@ -266,6 +266,8 @@ specification is required at minimum:
   what allocation function to use.  It should be one of
   @indexed-racket['nonatomic] (uses @cpp{scheme_malloc} from
   Racket's C API), @indexed-racket['atomic]
+  (@cpp{scheme_malloc_atomic}), @indexed-racket['tagged]
+  (@cpp{scheme_malloc_tagged}), @indexed-racket['atomic]
   (@cpp{scheme_malloc_atomic}), @indexed-racket['stubborn]
   (@cpp{scheme_malloc_stubborn}), @indexed-racket['uncollectable]
   (@cpp{scheme_malloc_uncollectable}), @indexed-racket['eternal]
@@ -282,7 +284,9 @@ specification is required at minimum:
 
 If no mode is specified, then @racket['nonatomic] allocation is used
 when the type is a @racket[_gcpointer]- or @racket[_scheme]-based
-type, and @racket['atomic] allocation is used otherwise.}
+type, and @racket['atomic] allocation is used otherwise.
+
+@history[#:changed "6.4.0.10" @elem{Added the @racket['tagged] allocation mode.}]}
 
 
 @defproc[(free [cptr cpointer?]) void]{

pkgs/racket-doc/scribblings/foreign/types.scrbl

@@ -474,6 +474,7 @@ the later case, the result is the @racket[ctype]).}
                       [#:abi abi (or/c #f 'default 'stdcall 'sysv) #f]
                       [#:atomic? atomic? any/c #f]
                       [#:async-apply async-apply (or/c #f ((-> any/c) . -> . any/c) box?) #f]
+                      [#:lock-name lock-name (or/c string? #f) #f]
                       [#:in-original-place? in-original-place? any/c #f]
                       [#:save-errno save-errno (or/c #f 'posix 'windows) #f]
                       [#:wrapper wrapper (or/c #f (procedure? . -> . procedure?))
@@ -536,6 +537,12 @@ For @tech{callouts} to foreign functions with the generated type:
        (for example, grabbing a value stored in an ``output'' pointer
        and returning multiple values).}
 
+ @item{If @racket[lock-name] is not @racket[#f], then a process-wide
+       lock with the given name is held during the foreign call. In a
+       build that supports parallel places, @racket[lock-name] is
+       registered via @cpp{scheme_register_process_global}, so choose
+       names that are suitably distinct.}
+
  @item{If @racket[in-original-place?] is true, then when a foreign
        @tech{callout} procedure with the generated type is called in
        any Racket @tech-place[], the procedure
@@ -692,7 +699,8 @@ For @tech{callbacks} to Racket functions with the generated type:
        is not used.}
 
 ]
-}
+
+@history[#:changed "6.3" @elem{Added the @racket[#:lock-name] argument.}]}
 
 @defform/subs[#:literals (->> :: :)
               (_fun fun-option ... maybe-args type-spec ... ->> type-spec
@@ -702,6 +710,7 @@ For @tech{callbacks} to Racket functions with the generated type:
                            (code:line #:keep keep-expr)
                            (code:line #:atomic? atomic?-expr)
                            (code:line #:async-apply async-apply-expr)
+                           (code:line #:lock-name lock-name-expr)
                            (code:line #:in-original-place? in-original-place?-expr)
                            (code:line #:retry (retry-id [arg-id init-expr]))]
                [maybe-args code:blank
@@ -821,7 +830,8 @@ specifications:
 
 ]
 
-@history[#:changed "6.2" @elem{Added the @racket[#:retry] option.}]}
+@history[#:changed "6.2" @elem{Added the @racket[#:retry] option.}
+         #:changed "6.3" @elem{Added the @racket[#:lock-name] option.}]}
 
 @defproc[(function-ptr [ptr-or-proc (or cpointer? procedure?)]
                        [fun-type ctype?])
@@ -1013,13 +1023,11 @@ Racket vectors instead of lists.}
            (_bytes o len-expr)]]{
 
 A @tech{custom function type} that can be used by itself as a simple
-type for a byte string as a C pointer.  Alternatively, the second form
+type for a byte string as a C pointer. Coercion of a C pointer to
-is for a pointer return value, where the size should be explicitly
+simply @racket[_bytes] (without a specified length) requires that the pointer
-specified.
+refers to a nul-terminated byte string. When the length-specifying form is used
-
+for a function argument, a byte string is allocated with the given
-There is no need for other modes analogous to those of @racket[_ptr]:
+length, including an extra byte for the nul terminator.}
-input or input/output would be just like @racket[_bytes], since the
-string carries its size information.}
 
 
 @; ------------------------------------------------------------
@@ -1047,7 +1055,7 @@ members.}
 
 @defproc[(_list-struct [#:alignment alignment (or/c #f 1 2 4 8 16) #f] 
                        [#:malloc-mode malloc-mode
-                                      (one-of/c 'raw 'atomic 'nonatomic
+                                      (one-of/c 'raw 'atomic 'nonatomic 'tagged
                                                  'atomic-interior 'interior
                                                  'stubborn 'uncollectable 'eternal)
                                       'atomic]
@@ -1073,10 +1081,11 @@ below for a more efficient approach.
                     (property (code:line #:alignment alignment-expr)
                               (code:line #:malloc-mode malloc-mode-expr)
                               (code:line #:property prop-expr val-expr)
-                              #:no-equal)]
+                              #:no-equal
+                              #:define-unsafe)]
          #:contracts ([offset-expr exact-integer?]
                       [alignment-expr (or/c #f 1 2 4 8 16)]
-                      [malloc-mode-expr (one-of/c 'raw 'atomic 'nonatomic
+                      [malloc-mode-expr (one-of/c 'raw 'atomic 'nonatomic 'tagged
                                                   'atomic-interior 'interior
                                                   'stubborn 'uncollectable 'eternal)]
                       [prop-expr struct-type-property?])]{
@@ -1122,7 +1131,16 @@ The resulting bindings are as follows:
  @item{@racketidfont{set-}@racketvarfont{id}@racketidfont{-}@racket[field-id]@racketidfont{!}
   : a mutator function for each @racket[field-id].}
 
- @item{@racketvarfont{id}: structure-type information compatible with
+ @item{@racketvarfont{id}@racketidfont{-}@racket[field-id]@racketidfont{-offset}
+  : the absolute offset, in bytes, of each @racket[field-id], if @racket[#:define-unsafe] is present.}
+
+ @item{@racketidfont{unsafe-}@racketvarfont{id}@racketidfont{-}@racket[field-id]
+  : an unsafe accessor function for each @racket[field-id], if @racket[#:define-unsafe] is present.}
+
+ @item{@racketidfont{unsafe-set-}@racketvarfont{id}@racketidfont{-}@racket[field-id]@racketidfont{!}
+  : an unsafe mutator function for each @racket[field-id], if @racket[#:define-unsafe] is present.}
+
+@item{@racketvarfont{id}: structure-type information compatible with
   @racket[struct-out] or @racket[match] (but not @racket[struct] or 
   @racket[define-struct]);
   currently, this information is correct only when no @racket[super-id]
@@ -1320,7 +1338,8 @@ expects arguments for both the super fields and the new ones:
 ]
 
 @history[#:changed "6.0.0.6" @elem{Added @racket[#:malloc-mode].}
-         #:changed "6.1.1.8" @elem{Added @racket[#:offset] for fields.}]}
+#:changed "6.1.1.8" @elem{Added @racket[#:offset] for fields.}
+#:changed "6.3.0.13" @elem{Added @racket[#:define-unsafe].}]}
 
 @; ------------------------------------------------------------
 

pkgs/racket-doc/scribblings/guide/contracts/intro.scrbl

@@ -1,6 +1,7 @@
 #lang scribble/doc
 @(require scribble/manual scribble/eval "utils.rkt"
-          (for-label racket/contract))
+          (for-label racket/base
+                     racket/contract))
 
 @title[#:tag "contract-boundaries"]{Contracts and Boundaries}
 

pkgs/racket-doc/scribblings/guide/contracts/new-combinators.scrbl

@@ -67,13 +67,13 @@ The new argument specifies who is to be blamed for
 positive and negative contract violations.
 
 Contracts, in this system, are always
-established between two parties. One party provides some
+established between two parties. One party, called the server, provides some
-value according to the contract, and the other consumes the
+value according to the contract, and the other, the client, consumes the
-value, also according to the contract. The first is called
+value, also according to the contract. The server is called
-the ``positive'' person and the second the ``negative''. So,
+the positive position and the client the negative position. So,
 in the case of just the integer contract, the only thing
 that can go wrong is that the value provided is not an
-integer. Thus, only the positive party can ever accrue
+integer. Thus, only the positive party (the server) can ever accrue
 blame.  The @racket[raise-blame-error] function always blames
 the positive party.
 
@@ -114,16 +114,19 @@ This technique is not merely a cheap trick to get the example to work,
 however. The reversal of the positive and the negative is a
 natural consequence of the way functions behave. That is,
 imagine the flow of values in a program between two
-modules. First, one module defines a function, and then that
+modules. First, one module (the server) defines a function, and then that
-module is required by another. So far, the function itself
+module is required by another (the client). So far, the function itself
 has to go from the original, providing module to the
 requiring module. Now, imagine that the providing module
 invokes the function, supplying it an argument. At this
 point, the flow of values reverses. The argument is
 traveling back from the requiring module to the providing
-module! And finally, when the function produces a result,
+module! The client is ``serving'' the argument to the server,
+and the server is receiving that value as a client.
+And finally, when the function produces a result,
 that result flows back in the original
-direction. Accordingly, the contract on the domain reverses
+direction from server to client.
+Accordingly, the contract on the domain reverses
 the positive and the negative blame parties, just like the flow
 of values reverses.
 

pkgs/racket-doc/scribblings/guide/contracts/simple-function.scrbl

@@ -404,10 +404,13 @@ the contract so that error messages become intelligible:
 @interaction[#:eval 
              contract-eval
              (module improved-bank-server racket
-               (define (amount? x) (and (number? x) (integer? x) (>= x 0)))
+               (provide
-               (define amount (flat-named-contract 'amount amount?))
+                (contract-out
-  
+                 [deposit (-> (flat-named-contract
-               (provide (contract-out [deposit (amount . -> . any)]))
+                               'amount
+                               (λ (x)
+                                 (and (number? x) (integer? x) (>= x 0))))
+                              any)]))
 
                (define total 0)
                (define (deposit a) (set! total (+ a total))))]
@@ -446,5 +449,5 @@ In general, each contract error message consists of six sections:
           @item{a description of the precise aspect of the contract that was violated, @lines[1 2]}
           @item{the complete contract plus a path into it showing which aspect was violated, @lines[3 2]}
           @item{the module where the contract was put (or, more generally, the boundary that the contract mediates), @lines[5 1]}
-          @item{who was blamed, @lines[6 1]}
+          @item{who was blamed, @lines[6 2]}
-          @item{and the source location where the contract appears. @lines[7 1]}]
+          @item{and the source location where the contract appears. @lines[8 1]}]

pkgs/racket-doc/scribblings/guide/define-struct.scrbl

@@ -136,8 +136,11 @@ supertype.
 (define p (3d-posn 1 2 3))
 p
 (posn? p)
-(posn-x p)
 (3d-posn-z p)
+(code:comment "a 3d-posn has an x field, but there is no 3d-posn-x selector:")
+(3d-posn-x p)
+(code:comment "use the supertype's posn-x selector to access the x field:")
+(posn-x p)
 ]
 
 @; ------------------------------------------------------------
@@ -450,7 +453,7 @@ A @racket[_struct-option] always starts with a keyword:
   @racket[#:auto] field option. The constructor procedure does not
   accept arguments for automatic fields. Automatic fields are
   implicitly mutable (via reflective operations), but mutator
-  functions are bound only if @racket[#:mutator] is also specified.
+  functions are bound only if @racket[#:mutable] is also specified.
 
   @defexamples[
     (struct posn (x y [z #:auto])

pkgs/racket-doc/scribblings/guide/guide.scrbl

@@ -16,7 +16,7 @@ into details---covering much of the Racket toolbox, but leaving
 precise details to @|Racket| and other reference manuals.
 
 @margin-note{The source of this manual is available on
-@hyperlink["https://github.com/plt/racket/tree/master/pkgs/racket-doc/scribblings/guide"]{GitHub}.}
+@hyperlink["https://github.com/racket/racket/tree/master/pkgs/racket-doc/scribblings/guide"]{GitHub}.}
 
 @table-of-contents[]
 

pkgs/racket-doc/scribblings/guide/io.scrbl

@@ -69,10 +69,11 @@ file:
 (close-output-port out)
 ]
 
-Instead of having to match @racket[open-input-file] and
+Instead of having to match the open calls with close calls, most Racket
-@racket[open-output-file] calls, most Racket programmers will instead
+programmers will use the @racket[call-with-input-file] and
-use @racket[call-with-output-file], which takes a function to call
+@racket[call-with-output-file] functions which take a function to call to carry
-with the output port; when the function returns, the port is closed.
+out the desired operation. This function gets as its only argument the port,
+which is automatically opened and closed for the operation.
 
 @examples[
         #:eval io-eval
@@ -318,7 +319,7 @@ Other structure types created by @racket[struct], which offer
 more abstraction than @tech{prefab} structure types, normally
 @racket[write] either using @racketresultfont{#<....>} notation (for
 opaque structure types) or using @racketresultfont{#(....)} vector
-notation (for transparent structure types). In neither can the
+notation (for transparent structure types). In neither case can the
 result be read back in as an instance of the structure type:
 
 @interaction[

pkgs/racket-doc/scribblings/guide/let.scrbl

@@ -79,11 +79,11 @@ The difference is that each @racket[_id] is available for use in later
 visible one.
 
 @examples[
-(let* ([x (list "Borroughs")]
+(let* ([x (list "Burroughs")]
        [y (cons "Rice" x)]
        [z (cons "Edgar" y)])
   (list x y z))
-(let* ([name (list "Borroughs")]
+(let* ([name (list "Burroughs")]
        [name (cons "Rice" name)]
        [name (cons "Edgar" name)])
   name)
@@ -93,7 +93,7 @@ In other words, a @racket[let*] form is equivalent to nested
 @racket[let] forms, each with a single binding:
 
 @interaction[
-(let ([name (list "Borroughs")])
+(let ([name (list "Burroughs")])
   (let ([name (cons "Rice" name)])
     (let ([name (cons "Edgar" name)])
       name)))

pkgs/racket-doc/scribblings/guide/lists.scrbl

@@ -74,15 +74,7 @@ by @racket[and]ing or @racket[or]ing:
 (ormap number? (list "a" "b" 6))
 ]
 
-The @racket[filter] function keeps elements for which the body result
+The @racket[map], @racket[andmap], and @racket[ormap]
-is true, and discards elements for which it is @racket[#f]:
-
-@interaction[
-(filter string? (list "a" "b" 6))
-(filter positive? (list 1 -2 6 7 0))
-]
-
-The @racket[map], @racket[andmap], @racket[ormap], and @racket[filter]
 functions can all handle multiple lists, instead of just a single
 list. The lists must all have the same length, and the given function
 must accept one argument for each list:
@@ -93,6 +85,14 @@ must accept one argument for each list:
      (list 6 3 7))
 ]
 
+The @racket[filter] function keeps elements for which the body result
+is true, and discards elements for which it is @racket[#f]:
+
+@interaction[
+(filter string? (list "a" "b" 6))
+(filter positive? (list 1 -2 6 7 0))
+]
+
 The @racket[foldl] function generalizes some iteration functions. It
 uses the per-element function to both process an element and combine
 it with the ``current'' value, so the per-element function takes an

pkgs/racket-doc/scribblings/guide/macros.scrbl

@@ -15,6 +15,8 @@ make simple transformations easy to implement and reliable to
 use. Racket also supports arbitrary macro transformers that are
 implemented in Racket---or in a macro-extended variant of Racket.
 
+(For a bottom-up introduction of Racket macro, you may refer to: @(hyperlink "http://www.greghendershott.com/fear-of-macros/" "Fear of Macros"))
+
 @local-table-of-contents[]
 
 @;------------------------------------------------------------------------

pkgs/racket-doc/scribblings/guide/module-basics.scrbl

@@ -113,7 +113,7 @@ Racket tools all work automatically with relative paths. For example,
 
 @commandline{racket sort.rkt}
 
-on the comamnd line runs the @filepath{sort.rkt} program and
+on the command line runs the @filepath{sort.rkt} program and
 automatically loads and compiles required modules. With a large enough
 program, compilation from source can take too long, so use
 
@@ -205,7 +205,7 @@ provided by the @filepath{gui} package, while
 @filepath{parser-tools} library.@margin-note{More precisely,
 @racketmodname[racket/gui] is provided by @filepath{gui-lib},
 @racketmodname[parser-tools/lex] is provided by
-@filepath{parser-tools}, and the @filepath{gui} and
+@filepath{parser-tools-lib}, and the @filepath{gui} and
 @filepath{parser-tools} packages extend @filepath{gui-lib} and
 @filepath{parser-tools-lib} with documentation.}
 

pkgs/racket-doc/scribblings/guide/module-set.scrbl

@@ -34,7 +34,7 @@ modular reasoning about programs. For example, in the module,
   (provide rx:fish fishy-string?)
   (define rx:fish #rx"fish")
   (define (fishy-string? s)
-    (regexp-match? s rx:fish)))
+    (regexp-match? rx:fish s)))
 ]
 
 the function @racket[fishy-string?] will always match strings that

pkgs/racket-doc/scribblings/guide/other.scrbl

@@ -28,5 +28,10 @@ many other installed libraries. Run @exec{raco docs} to find
 documentation for libraries that are installed on your system and
 specific to your user account.
 
-@link["http://planet.plt-racket.org/"]{@|PLaneT|} offers even more
+@link["https://pkgs.racket-lang.org/"]{The Racket package repository}
-downloadable packages contributed by Racketeers.
+offer even more downloadable packages that are contributed by
+Racketeers.
+
+The legacy @link["http://planet.racket-lang.org/"]{@|PLaneT|} site
+offers additional packages, although maintained packages have
+generally migrated to the newer package repository.

pkgs/racket-doc/scribblings/guide/pattern-macros.scrbl

@@ -387,7 +387,7 @@ definition
 
 At the same time, @racket[define-cbr] needs to define @racket[do-f]
 using the body of @racket[f], this second part is slightly more
-complex, so we defer most it to a @racket[define-for-cbr] helper
+complex, so we defer most of it to a @racket[define-for-cbr] helper
 module, which lets us write @racket[define-cbr] easily enough:
 
 
@@ -453,11 +453,11 @@ Step-by-step, expansion proceeds as follows:
 @racketblock[
 (define-for-cbr do-f (a b)
   () (swap a b))
-=> (define-for-cbr do-f (b)
+(unsyntax @tt{=>}) (define-for-cbr do-f (b)
      ([a get_1 put_1]) (swap a b))
-=> (define-for-cbr do-f ()
+(unsyntax @tt{=>}) (define-for-cbr do-f ()
      ([a get_1 put_1] [b get_2 put_2]) (swap a b))
-=> (define (do-f get_1 get_2 put_1 put_2)
+(unsyntax @tt{=>}) (define (do-f get_1 get_2 put_1 put_2)
      (define-get/put-id a get_1 put_1)
      (define-get/put-id b get_2 put_2)
      (swap a b))

pkgs/racket-doc/scribblings/guide/performance.scrbl

@@ -2,7 +2,8 @@
 @(require scribble/manual "guide-utils.rkt"
           (for-label racket/flonum
                      racket/unsafe/ops
-                     racket/performance-hint))
+                     racket/performance-hint
+                     ffi/unsafe))
 
 @title[#:tag "performance"]{Performance}
 
@@ -358,6 +359,31 @@ crashes or memory corruption.
 
 @; ----------------------------------------------------------------------
 
+@section[#:tag "ffi-pointer-access"]{Foreign Pointers}
+
+The @racketmodname[ffi/unsafe] library provides functions for unsafely
+reading and writing arbitrary pointer values. The JIT recognizes uses
+of @racket[ptr-ref] and @racket[ptr-set!] where the second argument is
+a direct reference to one of the following built-in C types:
+@racket[_int8], @racket[_int16], @racket[_int32], @racket[_int64],
+@racket[_double], @racket[_float], and @racket[_pointer]. Then, if the
+first argument to @racket[ptr-ref] or @racket[ptr-set!] is a C pointer
+(not a byte string), then the pointer read or write is performed
+inline in the generated code.
+
+The bytecode compiler will optimize references to integer
+abbreviations like @racket[_int] to C types like
+@racket[_int32]---where the representation sizes are constant across
+platforms---so the JIT can specialize access with those C types. C
+types such as @racket[_long] or @racket[_intptr] are not constant
+across platforms, so their uses are currently not specialized by the
+JIT.
+
+Pointer reads and writes using @racket[_float] or @racket[_double] are
+not currently subject to unboxing optimizations.
+
+@; ----------------------------------------------------------------------
+
 @section[#:tag "regexp-perf"]{Regular Expression Performance}
 
 When a string or byte string is provided to a function like
@@ -445,7 +471,7 @@ then the expansion of the @racket[let] form to implement
 automatically converts the closure to pass itself @racket[n] as an
 argument instead.
 
-@section{Reachability and Garbage Collection}
+@section[#:tag "Reachability and Garbage Collection"]{Reachability and Garbage Collection}
 
 In general, Racket re-uses the storage for a value when the
 garbage collector can prove that the object is unreachable from
@@ -508,7 +534,7 @@ There are a number of exceptions, however:
          @item{Interned symbols are allocated only once (per place). A table inside
                Racket tracks this allocation so a symbol may not become garbage
                because that table holds onto it.}
-         @item{Reachability is only approximate with the CGC collector (i.e.,
+         @item{Reachability is only approximate with the @tech{CGC} collector (i.e.,
                a value may appear reachable to that collector when there is,
                in fact, no way to reach it anymore.}]
 
@@ -551,3 +577,53 @@ occurrence of the variable @racket[_fishes]. That constitutes
 a reference to the list, ensuring that the list is not itself
 garbage collected, and thus the red fish is not either.
 
+
+@section{Reducing Garbage Collection Pauses}
+
+By default, Racket's @tech{generational garbage collector} creates
+brief pauses for frequent @deftech{minor collections}, which inspect
+only the most recently allocated objects, and long pauses for infrequent
+@deftech{major collections}, which re-inspect all memory.
+
+For some applications, such as animations and games,
+long pauses due to a major collection can interfere
+unacceptably with a program's operation. To reduce major-collection
+pauses, the Racket garbage collector supports @deftech{incremental
+garbage-collection} mode. In incremental mode, minor collections
+create longer (but still relatively short) pauses by performing extra
+work toward the next major collection. If all goes well, most of a
+major collection's work has been performed by minor collections the
+time that a major collection is needed, so the major collection's
+pause is as short as a minor collection's pause. Incremental mode
+tends to run more slowly overall, but it can
+provide much more consistent real-time behavior.
+
+If the @envvar{PLT_INCREMENTAL_GC} environment variable is set
+to a value that starts with @litchar{1}, @litchar{y}, or @litchar{Y}
+when Racket starts, incremental mode is permanently enabled. Since
+incremental mode is only useful for certain parts of some programs,
+however, and since the need for incremental mode is a property of a
+program rather than its environment, the preferred way to enable
+incremental mode is with @racket[(collect-garbage 'incremental)].
+
+Calling @racket[(collect-garbage 'incremental)] does not perform an
+immediate garbage collection, but instead requests that each minor
+collection perform incremental work up to the next major collection.
+The request expires with the next major collection. Make a call to
+@racket[(collect-garbage 'incremental)] in any repeating task within
+an application that needs to be responsive in real time. Force a
+full collection with @racket[(collect-garbage)] just before an initial
+@racket[(collect-garbage 'incremental)] to initiate incremental mode
+from an optimal state.
+
+To check whether incremental mode is use and how it affects pause
+times, enable @tt{debug}-level logging output for the
+@racketidfont{GC} topic. For example,
+
+@commandline{racket -W "debuG@"@"GC error" main.rkt}
+
+runs @filepath{main.rkt} with garbage-collection logging to stderr
+(while preserving @tt{error}-level logging for all topics). Minor
+collections are reported by @litchar{min} lines, increment-mode minor
+collection are reported with @litchar{mIn} lines, and major
+collections are reported with @litchar{MAJ} lines.

pkgs/racket-doc/scribblings/guide/proc-macros.scrbl

@@ -67,13 +67,8 @@ to the same binding:
 (free-identifier=? #'car #'car)
 (require (only-in racket/base [car also-car]))
 (free-identifier=? #'car #'also-car)
-(free-identifier=? #'car (let ([car 8])
-                           #'car))
 ]
 
-The last example above, in particular, illustrates how syntax objects
-preserve lexical-context information.
-
 To see the lists, symbols, numbers, @|etc| within a syntax object, use
 @racket[syntax->datum]:
 

pkgs/racket-doc/scribblings/guide/reader-extension.scrbl

@@ -5,6 +5,8 @@
 
 @title[#:tag "hash-reader"]{Reader Extensions}
 
+@refdetails["parse-reader"]{reader extensions}
+
 The @tech{reader} layer of the Racket language can be extended through
 the @racketmetafont{#reader} form. A reader extension is implemented
 as a module that is named after @racketmetafont{#reader}. The module

pkgs/racket-doc/scribblings/guide/unit.scrbl

@@ -603,7 +603,7 @@ As a form for modularity, @racket[unit] complements @racket[module]:
 ]
 
 The @racket[lambda] and @racket[class] forms, among others, also allow
-paremetrization of code with respect to values that are chosen
+parameterization of code with respect to values that are chosen
 later. In principle, any of those could be implemented in terms of any
 of the others. In practice, each form offers certain
 conveniences---such as allowing overriding of methods or especially

pkgs/racket-doc/scribblings/guide/welcome.scrbl

@@ -204,7 +204,7 @@ To package the program as an executable, you have a few options:
 @; ----------------------------------------------------------------------
 @section[#:tag "use-module"]{A Note to Readers with Lisp/Scheme Experience}
 
-If you already know something about Racket or Lisp, you might be
+If you already know something about Scheme or Lisp, you might be
 tempted to put just
 
 @racketblock[

pkgs/racket-doc/scribblings/inside/embedding.scrbl

@@ -1,5 +1,6 @@
 #lang scribble/doc
-@(require "utils.rkt")
+@(require "utils.rkt"
+          scribble/bnf)
 
 @(define cgc-v-3m "CGC versus 3m")
 
@@ -10,7 +11,8 @@
 The Racket run-time system can be embedded into a larger program.  The
 embedding process for Racket CGC or Racket 3m (see @secref[cgc-v-3m])
 is essentially the same, but the process for Racket 3m is most easily
-understood as a variant of the process for Racket CGC.
+understood as a variant of the process for Racket CGC (even though
+Racket 3m is the standard variant of Racket).
 
 @section{CGC Embedding}
 
@@ -87,7 +89,7 @@ To embed Racket CGC in a program, follow these steps:
   @cpp{scheme_main_stack_setup} trampoline registers the C stack with
   the memory manager without creating a namespace.)
 
-  On 32-bit Windows, when support for parallelism is enabled in the Racket
+  On Windows, when support for parallelism is enabled in the Racket
   build (as is the default), then before calling
   @cpp{scheme_main_setup}, your embedding application must first call
   @cppi{scheme_register_tls_space}:
@@ -101,7 +103,12 @@ To embed Racket CGC in a program, follow these steps:
 
   @verbatim[#:indent 2]{
    static __declspec(thread) void *tls_space;
-  }}
+  }
+
+  @history[#:changed "6.3" @elem{Calling @cpp{scheme_register_tls_space} is
+                                 required on all Windows variants, although the call
+                                 may be a no-op, depending on how Racket is
+                                 built.}]}
 
  @item{Configure the namespace by adding module declarations. The
   initial namespace contains declarations only for a few primitive
@@ -109,16 +116,28 @@ To embed Racket CGC in a program, follow these steps:
   into the top-level environment.
 
   To embed a module like @racketmodname[racket/base] (along with all
-  its dependencies), use @exec{raco ctool --c-mods}, which generates a C file
+  its dependencies), use
+  @seclink["c-mods" #:doc raco-doc]{@exec{raco ctool --c-mods @nonterm{dest}}},
+  which generates a C file @nonterm{dest}
   that contains modules in bytecode form as encapsulated in a static
   array. The generated C file defines a @cppi{declare_modules}
   function that takes a @cpp{Scheme_Env*}, installs the modules into
   the environment, and adjusts the module name resolver to access the
-  embedded declarations.
+  embedded declarations. If embedded modules refer to runtime files
+  that need to be carried along, supply @DFlag{runtime} to
+  @exec{raco ctool --c-mods} to collect the runtime files into a
+  directory; see @secref[#:doc raco-doc "c-mods"] for more information.
 
-  Alternately, use @cpp{scheme_set_collects_path} and
+  Alternatively, use @cpp{scheme_set_collects_path} and
   @cpp{scheme_init_collection_paths} to configure and install a path
-  for finding modules at run time.}
+  for finding modules at run time.
+
+  On Windows, @exec{raco ctool --c-mods @nonterm{dest} --runtime
+  @nonterm{dest-dir}} includes in @nonterm{dest-dir} optional DLLs
+  that are referenced by the Racket library to support @tech[#:doc
+  reference-doc]{extflonums} and @racket[bytes-open-converter]. Call
+  @cpp{scheme_set_dll_path} to register @nonterm{dest-dir} so that
+  those DLLs can be found at run time.}
 
  @item{Access Racket through @cppi{scheme_dynamic_require},
   @cppi{scheme_load}, @cppi{scheme_eval}, and/or other functions
@@ -163,6 +182,7 @@ static int run(Scheme_Env *e, int argc, char *argv[])
 {
   Scheme_Object *curout;
   int i;
+  Scheme_Thread *th;
   mz_jmp_buf * volatile save, fresh;
 
   /* Declare embedded modules in "base.c": */
@@ -173,11 +193,13 @@ static int run(Scheme_Env *e, int argc, char *argv[])
   curout = scheme_get_param(scheme_current_config(), 
                             MZCONFIG_OUTPUT_PORT);
 
+  th = scheme_get_current_thread();
+
   for (i = 1; i < argc; i++) {
-    save = scheme_current_thread->error_buf;
+    save = th->error_buf;
-    scheme_current_thread->error_buf = &fresh;
+    th->error_buf = &fresh;
-    if (scheme_setjmp(scheme_error_buf)) {
+    if (scheme_setjmp(*th->error_buf)) {
-      scheme_current_thread->error_buf = save;
+      th->error_buf = save;
       return -1; /* There was an error */
     } else {
       Scheme_Object *v, *a[2];
@@ -188,7 +210,7 @@ static int run(Scheme_Env *e, int argc, char *argv[])
       a[0] = scheme_intern_symbol("racket/base");
       a[1] = scheme_intern_symbol("read-eval-print-loop");
       scheme_apply(scheme_dynamic_require(2, a), 0, NULL);
-      scheme_current_thread->error_buf = save;
+      th->error_buf = save;
     }
   }
   return 0;
@@ -200,6 +222,16 @@ int main(int argc, char *argv[])
 }
 }
 
+If modules embedded in the executable need to access runtime files
+(via @racketmodname[racket/runtime-path] forms), supply the
+@DFlag{runtime} flag to @exec{raco ctool}, specifying a directory
+where the runtime files are to be gathered. The modules in the
+generated @filepath{.c} file will then refer to the files in that
+directory; the directory is normally specified relative to the
+executable, but the embedding application must call
+@cppi{scheme_set_exec_cmd} to set the executable path (typically
+@cpp{argv[0]}) before declaring modules.
+
 On Mac OS X, or on Windows when Racket is compiled to a DLL
 using Cygwin, the garbage collector cannot find static variables
 automatically. In that case, @cppi{scheme_main_setup} must be called with a
@@ -279,15 +311,17 @@ static int run(Scheme_Env *e, int argc, char *argv[])
   Scheme_Object *curout = NULL, *v = NULL, *a[2] = {NULL, NULL};
   Scheme_Config *config = NULL;
   int i;
+  Scheme_Thread *th = NULL;
   mz_jmp_buf * volatile save = NULL, fresh;
 
-  MZ_GC_DECL_REG(8);
+  MZ_GC_DECL_REG(9);
   MZ_GC_VAR_IN_REG(0, e);
   MZ_GC_VAR_IN_REG(1, curout);
   MZ_GC_VAR_IN_REG(2, save);
   MZ_GC_VAR_IN_REG(3, config);
   MZ_GC_VAR_IN_REG(4, v);
-  MZ_GC_ARRAY_VAR_IN_REG(5, a, 2);
+  MZ_GC_VAR_IN_REG(5, th);
+  MZ_GC_ARRAY_VAR_IN_REG(6, a, 2);
 
   MZ_GC_REG();
 
@@ -299,11 +333,13 @@ static int run(Scheme_Env *e, int argc, char *argv[])
   config = scheme_current_config();
   curout = scheme_get_param(config, MZCONFIG_OUTPUT_PORT);
 
+  th = scheme_get_current_thread();
+
   for (i = 1; i < argc; i++) {
-    save = scheme_current_thread->error_buf;
+    save = th->error_buf;
-    scheme_current_thread->error_buf = &fresh;
+    th->error_buf = &fresh;
-    if (scheme_setjmp(scheme_error_buf)) {
+    if (scheme_setjmp(*th->error_buf)) {
-      scheme_current_thread->error_buf = save;
+      th->error_buf = save;
       return -1; /* There was an error */
     } else {
       v = scheme_eval_string(argv[i], e);
@@ -315,7 +351,7 @@ static int run(Scheme_Env *e, int argc, char *argv[])
       a[1] = scheme_intern_symbol("read-eval-print-loop");
       v = scheme_dynamic_require(2, a);
       scheme_apply(v, 0, NULL);
-      scheme_current_thread->error_buf = save;
+      th->error_buf = save;
     }
   }
 

pkgs/racket-doc/scribblings/inside/extensions.scrbl

@@ -206,7 +206,7 @@ which case the @DFlag{xform} step should be skipped.
 
 To create an extension that behaves as a module, return a symbol from
 @cpp{scheme_module_name}, and have @cpp{scheme_initialize} and
-@cpp{scheme_rename} declare a module using @cpp{scheme_primitive_module}.
+@cpp{scheme_reload} declare a module using @cpp{scheme_primitive_module}.
 
 For example, the following extension implements a module named
 @racket[hello] that exports a binding @racket[greeting]:

pkgs/racket-doc/scribblings/inside/hooks.scrbl

@@ -64,6 +64,13 @@ Sets the path to be returned by @racket[(find-system-path
 'addon-dir)].}
 
 
+@function[(void scheme_set_exec_cmd
+                [const-char* path])]{
+
+Sets the path to be returned by @racket[(find-system-path
+'exec-file)].}
+
+
 @function[(void scheme_init_collection_paths_post
            [Scheme_Env* env]
            [Scheme_Object* pre_extra_paths]
@@ -84,6 +91,15 @@ Like @cpp{scheme_init_collection_paths_post}, but with @racket[null]
 as the last argument.}
 
 
+@function[(void scheme_set_dll_path
+            [wchar_t* path])]{
+
+On Windows only, sets the path used to find optional DLLs that are used
+by the runtime system: @filepath{longdouble.dll} and one of @filepath{iconv.dll},
+@filepath{libiconv.dll}, or @filepath{libiconv-2.dll}. The given @var{path}
+should be an absolute path.}
+
+
 @function[(void scheme_seal_parameters)]{
 
 Takes a snapshot of the current values of built-in parameters. These

pkgs/racket-doc/scribblings/inside/memory.scrbl

@@ -196,28 +196,28 @@ A size procedure simply takes a pointer to an object with the tag and
 returns its size in words (not bytes). The @cppi{gcBYTES_TO_WORDS}
 macro converts a byte count to a word count.
 
-A mark procedure is used to trace references among objects without
+A mark procedure is used to trace references among objects. The
-moving any objects. The procedure takes a pointer to an object, and it
+procedure takes a pointer to an object, and it should apply the
-should apply the @cppi{gcMARK} macro to every pointer within the
+@cppi{gcMARK} macro to every pointer within the object. The mark
-object.  The mark procedure should return the same result as the size
+procedure should return the same result as the size procedure.
-procedure.
 
-A fixup procedure is used to update references to objects after or
+A fixup procedure is potentially used to update references to objects
-while they are moved. The procedure takes a pointer to an object, and
+that have moved, although the mark procedure may have moved objects
-it should apply the @cppi{gcFIXUP} macro to every pointer within the
+and updated references already. The fixup procedure takes a pointer to
-object; the expansion of this macro takes the address of its
+an object, and it should apply the @cppi{gcFIXUP} macro to every
-argument. The fixup procedure should return the same result as the
+pointer within the object. The fixup procedure should return the same
-size procedure.
+result as the size procedure.
 
-Depending on the collector's implementation, the mark or fixup
+Depending on the collector's implementation, the @cpp{gcMARK} and/or
-procedure might not be used. For example, the collector may only use
+@cpp{gcFIXUP} macros may take take the address of their arguments, and
-the mark procedure and not actually move the object. Or it may use the
+the fixup procedure might not be used. For example, the collector may
-fixup procedure to mark and move objects at the same time. To
+only use the mark procedure and not actually move the object. Or it
-dereference an object pointer during a fixup procedure, use
+may use mark to move objects at the same time. To dereference an
+object pointer during a mark or fixup procedure, use @cppi{GC_resolve}
+to convert a potentially old address to the location where the object
+has been moved. To dereference an object pointer during a fixup procedure, use
 @cppi{GC_fixup_self} to convert the address passed to the procedure to
-refer to the potentially moved object, and use @cppi{GC_resolve} to
+refer to the potentially moved object.
-convert an address that is not yet fixed up to determine the object's
-current location.
 
 When allocating a tagged object in 3m, the tag must be installed
 immediately after the object is allocated---or, at least, before the
@@ -899,7 +899,7 @@ overflow.}
            [void* ptr]
            [int   tls_index])]{
 
-Only available on 32-bit Windows; registers @var{ptr} as the address of a
+For Windows, registers @var{ptr} as the address of a
  thread-local pointer variable that is declared in the main
  executable. The variable's storage will be used to implement
  thread-local storage within the Racket run-time. See
@@ -908,7 +908,10 @@ Only available on 32-bit Windows; registers @var{ptr} as the address of a
 The @var{tls_index} argument must be @cpp{0}. It is currently
  ignored, but a future version may use the argument to allow
  declaration of the thread-local variable in a dynamically linked
- DLL.}
+ DLL.
+
+@history[#:changed "6.3" @elem{Changed from available only on 32-bit Windows
+                               to available on all Windows variants.}]}
 
 @function[(void scheme_register_static
            [void* ptr]
@@ -1106,9 +1109,7 @@ If the result of the size procedure is a constant, then pass a
 
 3m only. Can be called by a size, mark, or fixup procedure that is registered
 with @cpp{GC_register_traversers}. It returns the current address of
-an object @var{p} that might have been moved already, where @var{p}
+an object @var{p} that might have been moved already. This translation is necessary, for
-corresponds to an object that is referenced directly by the object
-being sized, marked, or fixed. This translation is necessary, for
 example, if the size or structure of an object depends on the content
 of an object it references. For example, the size of a class instance
 usually depends on a field count that is stored in the class. A fixup
@@ -1120,13 +1121,58 @@ fixing it.}
 
 3m only. Can be called by a fixup procedure that is registered with
 @cpp{GC_register_traversers}. It returns the final address of @var{p},
-which must be the pointer passed to the fixup procedure. For some
+which must be the pointer passed to the fixup procedure. The
+@cpp{GC_resolve} function would produce the same result, but
+@cpp{GC_fixup_self} may be more efficient. For some
 implementations of the memory manager, the result is the same as
 @var{p}, either because objects are not moved or because the object is
 moved before it is fixed. With other implementations, an object might
 be moved after the fixup process, and the result is the location that
 the object will have after garbage collection finished.}
 
+
+@function[(void scheme_register_type_gc_shape [short type]
+                                              [intptr_t* shape])]{
+
+Like @cpp{GC_register_traversers}, but using a set of predefined
+functions that interpret @var{shape} to traverse a value. The
+@var{shape} array is a sequence of commands terminated with
+@cpp{SCHEME_GC_SHAPE_TERM}, where each command has a single argument.
+
+Commands:
+
+@itemlist[
+
+ @item{@tt{#define @cppdef{SCHEME_GC_SHAPE_TERM} 0} --- the terminator
+       command, which has no argument.}
+
+ @item{@tt{#define @cppdef{SCHEME_GC_SHAPE_PTR_OFFSET} 1} ---
+       specifies that a object tagged with @var{type} has a pointer
+       to be made visible to the garbage collector, where the command
+       argument is the offset from the beginning of the object.}
+
+ @item{@tt{#define @cppdef{SCHEME_GC_SHAPE_ADD_SIZE} 2} --- specifies
+       the allocated size of an object tagged with @var{type},
+       where the command argument is an amount to add to an
+       accumulated size; currently, size information is not used, but
+       it may be needed with future implementations of the garbage
+       collector.}
+
+]
+
+To improve forward compatibility, any other command is assumed to take
+a single argument and is ignored.
+
+A GC-shape registration is place-specific, even though
+@cpp{scheme_make_type} creates a type tag that spans places. If a
+traversal is already installed for @cpp{type} in the current place,
+the old traversal specification is replaced. The
+@cpp{scheme_register_type_gc_shape} function keeps its own copy of the
+array @var{shape}, so the array need not be retained.
+
+@history[#:added "6.4.0.10"]}
+
+
 @function[(Scheme_Object* scheme_add_gc_callback [Scheme_Object* pre_desc]
                                                  [Scheme_Object* post_desc])]{
 

pkgs/racket-doc/scribblings/inside/misc.scrbl

@@ -364,10 +364,12 @@ any place.}
                  [void* val])]{
 
 Gets or sets a value in a process-global table (i.e., shared across
-multiple places, if any). If @var{val} is NULL, the current mapping
+multiple places, if any). If @var{val} is @cpp{NULL}, the current mapping
-for @var{key} is given, otherwise @var{val} is installed as the value
+for @var{key} is given. If @var{val} is not @cpp{NULL}, and no value has been
-for @var{key} and @cpp{NULL} is returned. The given @var{val} must not
+installed for that @var{key}, then the value is installed and @cpp{NULL} is returned. If a
-refer to garbage-collected memory.
+value has already been installed, then no new value is installed and the old
+value is returned. The given @var{val} must not refer to garbage-collected
+memory.
 
 This function is intended for infrequent use with a small number of
 keys.}

pkgs/racket-doc/scribblings/inside/overview.scrbl

@@ -41,7 +41,7 @@ source distribution from @url{http://download.racket-lang.org};
 detailed build instructions are in the @filepath{README} file in the
 top-level @filepath{src} directory. You can also get the latest
 sources from the @tt{git} repository at
-@url{https://github.com/plt/racket}, but beware that the repository is
+@url{https://github.com/racket/racket}, but beware that the repository is
 one step away from a normal source distribution, and it provides build
 modes that are more suitable for developing Racket itself; see
 @filepath{INSTALL.txt} in the @tt{git} repository for more

pkgs/racket-doc/scribblings/inside/params.scrbl

@@ -45,6 +45,13 @@ through the following indices:
 @item{@cppdef{MZCONFIG_CAN_READ_COMPILED} --- @racket[read-accept-compiled]}
 @item{@cppdef{MZCONFIG_CAN_READ_BOX} --- @racket[read-accept-box]}
 @item{@cppdef{MZCONFIG_CAN_READ_PIPE_QUOTE} --- @racket[read-accept-bar-quote]}
+@item{@cppdef{MZCONFIG_CAN_READ_DOT} --- @racket[read-accept-dot]}
+@item{@cppdef{MZCONFIG_CAN_READ_INFIX_DOT} --- @racket[read-accept-infix-dot]}
+@item{@cppdef{MZCONFIG_CAN_READ_QUASI} --- @racket[read-accept-quasiquote]}
+@item{@cppdef{MZCONFIG_CAN_READ_READER} --- @racket[read-accept-reader]}
+@item{@cppdef{MZCONFIG_CAN_READ_LANG} --- @racket[read-accept-lang]}
+@item{@cppdef{MZCONFIG_READ_DECIMAL_INEXACT} --- @racket[read-decimal-as-inexact]}
+@item{@cppdef{MZCONFIG_READ_CDOT} --- @racket[read-cdot]}
 
 @item{@cppdef{MZCONFIG_PRINT_GRAPH} --- @racket[print-graph]}
 @item{@cppdef{MZCONFIG_PRINT_STRUCT} --- @racket[print-struct]}
@@ -53,6 +60,8 @@ through the following indices:
 @item{@cppdef{MZCONFIG_CASE_SENS} --- @racket[read-case-sensitive]}
 @item{@cppdef{MZCONFIG_SQUARE_BRACKETS_ARE_PARENS} --- @racket[read-square-brackets-as-parens]}
 @item{@cppdef{MZCONFIG_CURLY_BRACES_ARE_PARENS} --- @racket[read-curly-braces-as-parens]}
+@item{@cppdef{MZCONFIG_SQUARE_BRACKETS_ARE_TAGGED} --- @racket[read-square-brackets-with-tag]}
+@item{@cppdef{MZCONFIG_CURLY_BRACES_ARE_TAGGED} --- @racket[read-curly-braces-with-tag]}
 
 @item{@cppdef{MZCONFIG_ERROR_PRINT_WIDTH} --- @racket[error-print-width]}
 

pkgs/racket-doc/scribblings/inside/threads.scrbl

@@ -9,7 +9,8 @@ Racket thread; all other threads are created through calls to
 
 Information about each internal Racket thread is kept in a
 @cppi{Scheme_Thread} structure. A pointer to the current thread's
-structure is available as @cppi{scheme_current_thread}.  A
+structure is available as @cppdef{scheme_current_thread} or
+from @cppi{scheme_get_current_thread}.  A
 @cpp{Scheme_Thread} structure includes the following fields:
 
 @itemize[
@@ -378,6 +379,12 @@ The following function @cpp{mzsleep} is an appropriate
 
 @section{Thread Functions}
 
+@function[(Scheme_Thread* scheme_get_current_thread)]{
+
+Returns the currently executing thread. The result is equivalent to
+@cppi{scheme_current_thread}, but the function form must be used in
+some embedding contexts.}
+
 @function[(Scheme_Object* scheme_thread
            [Scheme_Object* thunk])]{
 

pkgs/racket-doc/scribblings/inside/utils.rkt

@@ -12,6 +12,7 @@
          function subfunction
          FormatD
          tech-place
+         reference-doc raco-doc
          (except-out (all-from-out scribble/manual) var)
          (for-label (all-from-out scheme/base)))
 
@@ -157,8 +158,11 @@
 
 (define mzc (exec "raco ctool"))
 
+(define reference-doc '(lib "scribblings/reference/reference.scrbl"))
+(define raco-doc '(lib "scribblings/raco/raco.scrbl"))
+
 (define (refsecref s)
-  (secref #:doc '(lib "scribblings/reference/reference.scrbl") s))
+  (secref #:doc reference-doc s))
 
 (define Racket
   (other-manual '(lib "scribblings/reference/reference.scrbl")))

pkgs/racket-doc/scribblings/inside/values.scrbl

@@ -296,6 +296,9 @@ There are six global constants:
 
 ]
 
+In some embedding contexts, the function forms
+@cppi{scheme_make_null}, etc., must be used, instead.
+
 @; ----------------------------------------------------------------------
 
 @section[#:tag "im:strings"]{Strings}
@@ -325,6 +328,31 @@ For more fine-grained control over UTF-8 encoding, use the
 
 @section{Value Functions}
 
+@function[(Scheme_Object* scheme_make_null)]{
+
+Returns @cppi{scheme_null}.
+}
+
+@function[(Scheme_Object* scheme_make_eof)]{
+
+Returns @cppi{scheme_eof}.
+}
+
+@function[(Scheme_Object* scheme_make_true)]{
+
+Returns @cppi{scheme_true}.
+}
+
+@function[(Scheme_Object* scheme_make_false)]{
+
+Returns @cppi{scheme_false}.
+}
+
+@function[(Scheme_Object* scheme_make_void)]{
+
+Returns @cppi{scheme_void}.
+}
+
 @function[(Scheme_Object* scheme_make_char
            [mzchar ch])]{
 

pkgs/racket-doc/scribblings/more/more.scrbl

@@ -747,7 +747,7 @@ import a library of control operators:
 Specifically, we need @racket[prompt] and @racket[abort] from
 @racketmodname[racket/control]. We use @racket[prompt] to mark the
 place where a servlet is started, so that we can abort a computation
-to that point. Change @racket[handle] by wrapping an @racket[prompt]
+to that point. Change @racket[handle] by wrapping a @racket[prompt]
 around the call to @racket[dispatch]:
 
 @racketblock[

pkgs/racket-doc/scribblings/raco/api.scrbl

@@ -2,6 +2,7 @@
 
 @(require scribble/manual
           scribble/bnf
+          "common.rkt"
           (for-label scheme/gui
                      compiler/compiler
                      compiler/sig
@@ -12,7 +13,9 @@
                      dynext/compile-sig
                      dynext/link-sig
                      dynext/file-sig
-                     launcher/launcher))
+                     launcher/launcher
+                     compiler/module-suffix
+                     setup/getinfo))
 
 @title{API for Raw Compilation}
 
@@ -70,6 +73,7 @@ file is reported through the current output port.}
 
 @defproc[(compile-collection-zos [collection string?] ...+
                                  [#:skip-path skip-path (or/c path-string? #f) #f]
+                                 [#:skip-paths skip-paths (listof path-string?) null]
                                  [#:skip-doc-sources? skip-docs? any/c #f]
                                  [#:managed-compile-zo managed-compile-zo 
                                                        (path-string? . -> . void?)
@@ -83,8 +87,10 @@ The @filepath{.zo} files are placed into the collection's
 
 By default, all files with the
 extension @filepath{.rkt}, @filepath{.ss}, or @filepath{.scm} in a collection are
-compiled, as are all such files within subdirectories, execept that
+compiled, as are all such files within subdirectories; the set of such suffixes
-any file or directory whose path starts with @racket[skip-path] is
+is extensible globally as described in @racket[get-module-suffixes], and
+@racket[compile-collection-zos] recognizes suffixes from the @racket['libs] group. However,
+any file or directory whose path starts with @racket[skip-path] or an element of @racket[skip-paths] is
 skipped. (``Starts with'' means that the simplified path @racket[_p]'s
 byte-string form after @racket[(simplify-path _p #f)]starts with the
 byte-string form of @racket[(simplify-path skip-path #f)].)
@@ -113,24 +119,33 @@ collection.  The following fields are used:
        field's value is @racket['all].}
 
  @item{@indexed-racket[compile-omit-files] : A list of filenames (without
-       directory paths); that are not compiled, in addition to the
+       directory paths) that are not compiled, in addition to the
        contents of @racket[compile-omit-paths].  Do not use this
        field; it is for backward compatibility.}
 
  @item{@indexed-racket[scribblings] : A list of pairs, each of which
        starts with a path for documentation source. The sources (and
        the files that they require) are compiled in the same way as
-       @filepath{.rkt}, @filepath{.ss}, and @filepath{.scm} files,
+       other module files, unless @racket[skip-docs?] is a true value.}
-       unless the provided @racket[skip-docs?] argument is a true
-       value.}
 
-]}
+ @item{@indexed-racket[compile-include-files] : A list of filenames (without
+       directory paths) to be compiled, in addition to files that
+       are compiled based on the file's extension, being in @racket[scribblings],
+       or being @racket[require]d by other compiled files.}
+
+ @item{@racket[module-suffixes] and @racket[doc-module-suffixes] ---
+       Used indirectly via @racket[get-module-suffixes].}
+
+]
+
+@history[#:changed "6.3" @elem{Added support for @racket[compile-include-files].}]}
 
 
 @defproc[(compile-directory-zos [path path-string?]
                                 [info ()]
                                 [#:verbose verbose? any/c #f]
                                 [#:skip-path skip-path (or/c path-string? #f) #f]
+                                [#:skip-paths skip-paths (listof path-string?) null]
                                 [#:skip-doc-sources? skip-docs? any/c #f]
                                 [#:managed-compile-zo managed-compile-zo 
                                                       (path-string? . -> . void?)
@@ -142,6 +157,69 @@ rather than a collection. The @racket[info] function behaves like the
 result of @racket[get-info] to supply @filepath{info.rkt} fields,
 instead of using an @filepath{info.rkt} file (if any) in the directory.}
 
+@; ----------------------------------------------------------------------
+
+@section[#:tag "module-suffix"]{Recognizing Module Suffixes}
+
+@defmodule[compiler/module-suffix]{The
+@racketmodname[compiler/module-suffix] library provides functions for
+recognizing file suffixes that correspond to Racket modules for the
+purposes of compiling files in a directory, running tests for files in
+a directory, and so on. The set of suffixes always includes
+@filepath{.rkt}, @filepath{.ss}, and @filepath{.scm}, but it can be
+extended globally by @filepath{info.rkt} configuration in collections.}
+
+@history[#:added "6.3"]
+
+@defproc[(get-module-suffixes [#:group group (or/c 'all 'libs 'docs) 'all]
+                              [#:mode mode (or/c 'preferred 'all-available 'no-planet 'no-user) 'preferred]
+                              [#:namespace namespace (or/c #f namespace?) #f])
+         (listof bytes?)]{
+
+Inspects @filepath{info.rkt} files (see @secref["info.rkt"]) of
+installed collections to produce a list of file suffixes that should
+be recognized as Racket modules. Each suffix is reported as a byte
+string that does not include the @litchar{.} that precedes a suffix.
+
+The @racket[mode] and @racket[namespace] arguments are propagated to
+@racket[find-relevant-directories] to determine which collection
+directories might configure the set of suffixes. Consequently, suffix
+registrations are found reliably only if @exec{raco setup} (or package
+installations or updates that trigger @exec{raco setup}) is run.
+
+The @racket[group] argument determines whether the result includes all
+registered suffixes, only those that are registered as general library
+suffixes, or only those that are registered as documentation suffixes.
+The set of general-library suffixes always includes @filepath{.rkt},
+@filepath{.ss}, and @filepath{.scm}. The set of documentation suffixes
+always includes @filepath{.scrbl}.
+
+The following fields in an @filepath{info.rkt} file extend the set of
+suffixes:
+
+@itemize[
+
+ @item{@indexed-racket[module-suffixes] : A list of byte strings that
+       correspond to general-library module suffixes (without the
+       @litchar{.} that must appear before the suffix). Non-lists or
+       non-byte-string elements of the list are ignored.}
+
+ @item{@indexed-racket[doc-module-suffixes] : A list of byte strings
+       as for @racket[module-suffixes], but for documentation
+       modules.}
+
+]}
+
+@defproc[(get-module-suffix-regexp [#:group group (or/c 'all 'libs 'docs) 'all]
+                                   [#:mode mode (or/c 'preferred 'all-available 'no-planet 'no-user) 'preferred]
+                                   [#:namespace namespace (or/c #f namespace?) #f])
+         byte-regexp?]{
+
+Returns a @tech[#:doc reference-doc]{regexp value} that matches paths ending
+with a suffix as reported by @racket[get-module-suffixes]. The pattern
+includes a subpatterns for the suffix without its leading @litchar{.}}
+
+
 @; ----------------------------------------------------------------------
 
 @section[#:tag "api:loading"]{Loading Compiler Support}

pkgs/racket-doc/scribblings/raco/c-mods.scrbl

@@ -1,5 +1,7 @@
 #lang scribble/doc
-@(require scribble/manual "common.rkt")
+@(require scribble/manual
+          "common.rkt"
+          scribble/bnf)
 
 @title[#:tag "c-mods"]{Embedding Modules via C}
 
@@ -14,3 +16,39 @@ a @tt{declare_modules} function that puts the module declarations into
 a namespace. Thus, using the output of @exec{raco ctool --c-mods}, a
 program can embed Racket with a set of modules so that it does not
 need a @filepath{collects} directory to load modules at run time.
+
+If the embedded modules refer to runtime files, the files can be
+gathers by supplying the @DFlag{runtime} argument to @exec{raco ctool
+--cmods}, specifying a directory @nonterm{dir} to hold the files.
+Normally, @nonterm{dir} is a relative path, and files are found at run
+time in @nonterm{dir} relative to the executable, but a separate path
+(usually relative) for run time can be specified with
+@DFlag{runtime-access}.
+
+
+Typically, @exec{raco ctool --c-mods} is used with @DPFlag{lib} to
+specify a collection-based module path. For example,
+
+@commandline{raco ctool --c-mods base.c ++lib racket/base}
+
+generates a @filepath{base.c} whose @tt{declare_modules} function
+makes @racketmodname[racket/base] available for use via the
+@tt{scheme_namespace_require} or @tt{scheme_dynamic_require} functions
+within the embedding application.
+
+When a module file is provided to @exec{raco ctool --c-mods}, then
+@tt{declare_modules} declares a module with the symbolic name of the
+module file. For example, 
+
+@commandline{raco ctool --c-mods base.c hello.rkt}
+
+creates a @tt{declare_modules} that defines the module
+@racket['hello], which could be required into the current namespace
+with @racket[(namespace-require ''hello)] or similarly at the C level:
+
+@verbatim[#:indent 2]{
+  p = scheme_make_pair(scheme_intern_symbol("quote"),
+                       scheme_make_pair(scheme_intern_symbol("hello"),
+                                        scheme_make_null()));
+  scheme_namespace_require(p);
+}

pkgs/racket-doc/scribblings/raco/common.rkt

@@ -7,5 +7,8 @@
 (define inside-doc
   '(lib "scribblings/inside/inside.scrbl"))
 
+(define guide-doc
+  '(lib "scribblings/guide/guide.scrbl"))
+
 (define reference-doc
   '(lib "scribblings/reference/reference.scrbl"))

pkgs/racket-doc/scribblings/raco/decompile.scrbl

@@ -104,7 +104,10 @@ Many forms in the decompiled code, such as @racket[module],
 
 @item{A form @racket[(#%apply-values _proc _expr)] is equivalent to
  @racket[(call-with-values (lambda () _expr) _proc)], but the run-time
- system avoids allocating a closure for @racket[_expr].}
+ system avoids allocating a closure for @racket[_expr]. Similarly,
+ a @racket[#%call-with-immediate-continuation-mark] call is equivalent to
+ a @racket[call-with-immediate-continuation-mark] call, but avoiding
+ a closure allocation.}
 
 @item{A @racket[define-values] form may have @racket[(begin
  '%%inline-variant%% _expr1 _expr2)] for its expression, in which case

pkgs/racket-doc/scribblings/raco/dist-api.scrbl

@@ -16,17 +16,26 @@ perform the same work as @exec{raco distribute}.}
 
 @defproc[(assemble-distribution [dest-dir path-string?]
                                 [exec-files (listof path-string?)]
+                                [#:executables? executables? any/c #t]
+                                [#:relative-base relative-base (or/c path-string? #f) #f]
                                 [#:collects-path path (or/c false/c (and/c path-string? relative-path?)) #f]
                                 [#:copy-collects dirs (listof path-string?) null])
          void?]{
 
 Copies the executables in @racket[exec-files] to the directory
-@racket[dest-dir], along with DLLs, frameworks, and/or shared
+@racket[dest-dir], along with DLLs, frameworks, shared libraries,
-libraries that the executables need to run a different machine.
+and/or runtime files that the executables need to run a different
+machine. If @racket[executables?] is @racket[#f], then the
+@racket[exec-files] are treated as plain data files, instead of
+executables, and they are modified in-place.
 
 The arrangement of the executables and support files in
-@racket[dest-dir] depends on the platform. In general
+@racket[dest-dir] depends on the platform. In general,
-@racket[assemble-distribution] tries to do the Right Thing.
+@racket[assemble-distribution] tries to do the Right Thing, but a
+non-@racket[#f] value for @racket[relative-base] specifies a
+path for reaching the assembled content relative to the executable at
+run time. When @racket[executables?] is @racket[#f], then the default
+access path is @racket[dest-dir], with its relativeness preserved.
 
 If a @racket[#:collects-path] argument is given, it overrides the
 default location of the main @filepath{collects} directory for the
@@ -35,4 +44,7 @@ directory (typically inside it).
 
 The content of each directory in the @racket[#:copy-collects] argument
 is copied into the main @filepath{collects} directory for the packaged
-executables.}
+executables.
+
+@history[#:changed "6.3" @elem{Added the @racket[#:executables?]
+                                      and @racket[#:relative-base] arguments.}]}

pkgs/racket-doc/scribblings/raco/exe-api.scrbl

@@ -187,11 +187,11 @@ currently supported keys are as follows:
         @filepath{.icns}) to use for the executable's desktop icon.}
 
   @item{@racket['ico] (Windows) : An icon file path (suffix
-        @filepath{.ico}) to use for the executable's desktop icon;
+        @filepath{.ico}) to use for the executable's desktop icon.
-        the executable will have 16x16, 32x32, and 48x48 icons at
+
-        4-bit, 8-bit, and 32-bit (RGBA) depths; the icons are copied
+        @history[#:changed "6.3" @elem{All icons in the
-        and generated from any 16x16, 32x32, and 48x48 icons in the
+        executable are replaced with icons from the file,
-        @filepath{.ico} file.}
+        instead of setting only certain sizes and depths.}]}
 
   @item{@racket['creator] (Mac OS X) : Provides a 4-character string
         to use as the application signature.}
@@ -473,9 +473,17 @@ A unit that imports nothing and exports @racket[compiler:embed^].}
 
 @defmodule[compiler/find-exe]
 
-@defproc[(find-exe [gracket? any/c #f]
+@defproc[(find-exe [#:cross? cross? any/c #f]
-                   [variant (or/c 'cgc '3m) (system-type 'gc)])
+                   [gracket? any/c #f]
+                   [variant (or/c 'cgc '3m) (if cross?
+                                                (cross-system-type 'gc)
+                                                (system-type 'gc))])
          path?]{
 
   Finds the path to the @exec{racket} or @exec{gracket} (when
-  @racket[gracket?] is true) executable.}
+  @racket[gracket?] is true) executable.
+
+  If @racket[cross?] is true, the executable is found for the target
+  platform in @seclink["cross-system"]{cross-installation mode}.
+
+  @history[#:changed "6.3" @elem{Added the @racket[#:cross?] argument.}]}

pkgs/racket-doc/scribblings/raco/exe-dylib-path.scrbl

@@ -0,0 +1,36 @@
+#lang scribble/manual
+@(require "common.rkt"
+          (for-label racket/base
+                     racket/contract
+                     compiler/exe-dylib-path))
+
+@title[#:tag "exe-dylib-path"]{Mac OS X Dynamic Library Paths}
+
+@defmodule[compiler/exe-dylib-path]{The
+@racketmodname[compiler/exe-dylib-path] library provides functions for
+reading and adjusting dynamic-library references in a Mac OS X
+executable.}
+
+@history[#:added "6.3"]
+
+@defproc[(find-matching-library-path [exe-path path-string?]
+                                     [library-str string?])
+         (or/c #f string?)]{
+
+Searches dynamic-linking information in @racket[exe-path] for a
+library reference whose name includes @racket[library-str] and returns
+the executable's path to the library for the first match. If no match is
+found, the result is @racket[#f].}
+
+@defproc[(update-matching-library-path [exe-path path-string?]
+                                       [library-str string?]
+                                       [library-path-str string?])
+         void?]{
+
+Searches dynamic-linking information in @racket[exe-path] for each
+library reference whose name includes @racket[library-str] and replaces
+the executable's path to that library with @racket[library-path-str].
+
+A single match is expected, and the update assumes enough space for
+the new path, perhaps because the executable is linked with
+@Flag{headerpad_max_install_names}.}

pkgs/racket-doc/scribblings/raco/exe.scrbl

@@ -11,10 +11,11 @@
 
 @title[#:tag "exe"]{@exec{raco exe}: Creating Stand-Alone Executables}
 
-@margin-note{Use a smaller base language to achieve a faster startup time such
+@margin-note{To achieve a faster startup time, instead of trying
-as @racketmodfont{#lang} @racketmodname[racket/base] instead of
+@exec{raco exe}, use a smaller base language---such as
-@racketmodfont{#lang} @racketmodname[racket] rather than relying on @exec{raco
+@racketmodfont{#lang} @racketmodname[racket/base] instead of
-exe}.}
+@racketmodfont{#lang} @racketmodname[racket]. Also, ensure that
+bytecode files are compiled by using @seclink["make"]{@exec{raco make}}.}
 
 Compiled code produced by @exec{raco make} relies on Racket
 executables to provide run-time support to the compiled code. However,
@@ -49,7 +50,10 @@ created executable. Such modules can be explicitly included using the
 @racket[define-runtime-path] to embed references to the run-time files
 in the executable; the files are then copied and packaged together
 with the executable when creating a distribution (as described in
-@secref["exe-dist"]).
+@secref["exe-dist"]). Finally, a submodule is included if its
+enclosing module is included and the submodule contains a
+sub-submodule named @racketidfont{declare-preserve-for-embedding}
+(where the implementation of the sub-submodule is ignored).
 
 Modules that are implemented directly by extensions---i.e., extensions
 that are automatically loaded from @racket[(build-path "compiled"
@@ -85,8 +89,11 @@ The @exec{raco exe} command accepts the following command-line flags:
 
  @item{@Flag{l} or @DFlag{launcher} --- create a @tech{launcher} (see
    @secref["launcher"]), instead of a stand-alone executable. Flags
-   such as @DFlag{config-path}, @DFlag{collects-path}, and
+   such as @DFlag{config-path}, @DFlag{collects-path}, and @DFlag{lib}
-   @DFlag{lib} have no effect on launchers.}
+   have no effect on launchers. Beware that the default command-line
+   flags to build into the launcher prevent access to packages that
+   are installed in user scope; use @exec{--exf -U} to enable access
+   to user-scope packages from the launcher.}
 
  @item{@DFlag{config-path} @nonterm{path} --- set @nonterm{path}
    within the executable as the path to the @tech{configuration
@@ -110,7 +117,9 @@ The @exec{raco exe} command accepts the following command-line flags:
    included with the executable into @nonterm{path}
    (relative to the current directory), instead of embedded within the
    executable. The @DFlag{collects-dest} flag normally makes sense
-   only in combination with @DFlag{collects-path}.}
+   only in combination with @DFlag{collects-path}. This mode currently
+   does not prune unreferenced submodules (and it pulls along any
+   dependencies of submodules).}
 
  @item{@DFlag{ico} @nonterm{.ico-path} --- on Windows, set the icons
    for the generated executable to ones extracted from
@@ -148,19 +157,19 @@ The @exec{raco exe} command accepts the following command-line flags:
    in the executable, even if it is not referenced by the main program,
    so that it is available via @racket[dynamic-require].}
 
- @item{@DPFlag{exfl} @nonterm{flag} --- provide the @nonterm{flag}
+ @item{@DPFlag{exf} @nonterm{flag} --- provide the @nonterm{flag}
    command-line argument on startup to the embedded @exec{racket} or
    @exec{gracket}.}
 
- @item{@DFlag{exfl} @nonterm{flag} --- remove @nonterm{flag} from the
+ @item{@DFlag{exf} @nonterm{flag} --- remove @nonterm{flag} from the
    command-line arguments to be provided on startup to the embedded
    @exec{racket} or @exec{gracket}.}
 
- @item{@DFlag{exfl-clear} --- remove all command-line arguments to be
+ @item{@DFlag{exf-clear} --- remove all command-line arguments to be
    provided on startup to the embedded @exec{racket} or
    @exec{gracket}.}
 
- @item{@DFlag{exfl-show} --- show (without changing) the command-line
+ @item{@DFlag{exf-show} --- show (without changing) the command-line
    arguments to be provided on startup to the embedded
    @exec{racket} or @exec{gracket}.}
 
@@ -170,7 +179,12 @@ The @exec{raco exe} command accepts the following command-line flags:
 
 ]
 
+@history[#:changed "6.3.0.11" @elem{Added support for
+                                    @racketidfont{declare-preserve-for-embedding}.}]
+
 @; ----------------------------------------------------------------------
 
 @include-section["exe-api.scrbl"]
 @include-section["launcher.scrbl"]
+@include-section["exe-dylib-path.scrbl"]
+

pkgs/racket-doc/scribblings/raco/expand.scrbl

@@ -6,8 +6,8 @@
 
 @title[#:tag "expand"]{@exec{raco expand}: Macro Expansion}
 
-The @exec{raco expand} command macro expands the contents of
+The @exec{raco expand} command macro-expands and pretty-prints the
-the given source files. Also see @racket[expand].
+contents of the given source files. See also @racket[expand].
 
 Command-line flags:
 

pkgs/racket-doc/scribblings/raco/make.scrbl

@@ -8,7 +8,8 @@
                      racket/file
                      compiler/cm
                      compiler/cm-accomplice
-                     setup/parallel-build))
+                     setup/parallel-build
+                     compiler/compilation-path))
 
 
 @(define cm-eval (make-base-eval))
@@ -390,6 +391,29 @@ A parameter whose value is called for each file that is loaded and
  @racket[#f], then the file is compiled as usual. The default is
  @racket[(lambda (x) #f)].}
 
+
+@defparam[current-path->mode path->mode
+          (or/c #f (-> path? (and/c path? relative-path?)))
+          #:value #f]{
+ Used by @racket[make-compilation-manager-load/use-compiled-handler] and
+ @racket[make-caching-managed-compile-zo] to override @racket[use-compiled-file-paths]
+ for deciding where to write compiled @filepath{.zo} files. If it is @racket[#f],
+ then the first element of @racket[use-compiled-file-paths] is used. If it isn't
+ @racket[#f], then it is called with the original source file's location and its
+ result is treated the same as if it had been the first element of
+ @racket[use-compiled-file-paths].
+
+ Note that this parameter is not used by @racket[current-load/use-compiled]. So if
+ the parameter causes @filepath{.zo} files to be placed in different directories, then
+ the correct @filepath{.zo} file must still be communicated via @racket[use-compiled-file-paths],
+ and one way to do that is to override @racket[current-load/use-compiled] to delete
+ @filepath{.zo} files that would cause the wrong one to be chosen right before they are
+ loaded.
+
+ @history[#:added "6.4.0.14"]
+}
+
+
 @defproc[(file-stamp-in-collection [p path?]) (or/c (cons/c number? promise?) #f)]{
   Calls @racket[file-stamp-in-paths] with @racket[p] and
   @racket[(current-library-collection-paths)].}
@@ -497,6 +521,18 @@ result will not call @racket[proc] with @racket['unlock].)
             compilations of the same racket source files in multiple places.
 }
 
+@defproc[(install-module-hashes! [bstr btyes?]
+                                 [start exact-nonnegatve-integer? 0]
+                                 [end exact-nonnegatve-integer? (bytes-length bstr)])
+         void?]{
+
+Adjusts the bytecode representation in @racket[bstr] (from bytes
+@racket[start] to @racket[end]) to install a hash code, including any
+submodules within the region. The existing representation should have
+zero bytes in place of each hash string, which is what @racket[write]
+produces for a compiled form.
+
+@history[#:added "6.3"]}
 
 @; ----------------------------------------------------------------------
 
@@ -696,14 +732,14 @@ of @racket[modes] and @racket[roots].}
                               [#:roots roots (non-empty-listof (or/c path-string? 'same)) (current-compiled-file-roots)])
          path?]{
 
-The same as @racket[get-compilation-dir+home], but returning only the first result.}
+The same as @racket[get-compilation-dir+name], but returning only the first result.}
 
 @defproc[(get-compilation-bytecode-file [path path-string?]
                                         [#:modes modes (non-empty-listof (and/c path-string? relative-path?)) (use-compiled-file-paths)]
                                         [#:roots roots (non-empty-listof (or/c path-string? 'same)) (current-compiled-file-roots)])
          path?]{
 
-The same as @racket[get-compilation-dir+home], but combines the
+The same as @racket[get-compilation-dir+name], but combines the
 results and adds a @filepath{.zo} suffix to arrive at a bytecode file
 path.}
 

pkgs/racket-doc/scribblings/raco/raco.scrbl

@@ -30,6 +30,7 @@ a typical Racket installation.
 @include-section["test.scrbl"]
 @include-section["docs.scrbl"]
 @include-section["expand.scrbl"]
+@include-section["read.scrbl"]
 @include-section["scribble.scrbl"]
 @include-section["command.scrbl"]
 @include-section["config.scrbl"]

pkgs/racket-doc/scribblings/raco/read.scrbl

@@ -0,0 +1,26 @@
+#lang scribble/doc
+@(require scribble/manual
+          scribble/bnf
+          "common.rkt"
+          (for-label racket/base))
+
+@title[#:tag "read"]{@exec{raco read}: Reading and Pretty-Printing}
+
+@; to associate `history` to the right package:
+@(declare-exporting compiler/commands/read)
+
+The @exec{raco read} command @racket[read]s and pretty-prints the
+contents of the given files. This command is useful for showing
+how a @tt{#reader} or @hash-lang[]-based reader extension converts
+input to an S-expression. It is also useful for pretty-printing a term
+that is already in S-expression form.
+
+Command-line flags:
+
+@itemlist[
+  @item{@Flag{n} @nonterm{n} or @DFlag{columns} @nonterm{n}  --- format output for a display with @nonterm{n} columns}
+  @item{@Flag{h} or @DFlag{help} --- show help information for this command}
+  @item{@DFlag{} --- do not treat remaining arguments as switches}
+]
+
+@history[#:added "1.3"]

pkgs/racket-doc/scribblings/raco/setup.scrbl

@@ -12,7 +12,9 @@
                     setup/getinfo
                     setup/main-collects
                     setup/collection-name
+                    setup/collection-search
                     setup/matching-platform
+                    setup/cross-system
                     setup/path-to-relative
                     setup/xref scribble/xref
                     ;; info -- no bindings from this are used
@@ -21,6 +23,7 @@
                     setup/unpack
                     setup/link
                     compiler/compiler
+                    compiler/module-suffix
                     launcher/launcher
                     compiler/sig
                     launcher/launcher-sig
@@ -142,6 +145,11 @@ flags:
    set of deleted files can be controlled by @filepath{info.rkt}; see
    @elemref["clean"]{@racket[clean]} for more information.}
 
+ @item{@DFlag{fast-clean} or @Flag{c} --- like @DFlag{clean}, but
+   without forcing a bootstrap of @exec{raco setup} from source (which
+   means that @DFlag{fast-clean} cannot clean corruption that affects
+   @exec{raco setup} itself).}
+
  @item{@DFlag{no-zo} or @Flag{n} --- refrain from compiling source
    files to @filepath{.zo} files.}
 
@@ -358,8 +366,8 @@ Optional @filepath{info.rkt} fields trigger additional actions by
           (list src-string flags category name out-k)
           (list src-string flags category name out-k order-n)]
      [flags (list mode-symbol ...)]
-     [category (list category-symbol)
+     [category (list category-string-or-symbol)
-               (list category-symbol sort-number)]
+               (list category-string-or-symbol sort-number)]
      [name string
            #f]
    ]
@@ -374,7 +382,7 @@ Optional @filepath{info.rkt} fields trigger additional actions by
    documentation, instead of defaulting to the source file's name
    (sans extension), where @racket[#f] means to use the default; a
    non-@racket[#f] value for @racket[_name] must fit the grammar
-   of a colelction-name element as checked by 
+   of a collection-name element as checked by 
    @racket[collection-name-element?]. If a
    document's list contains a fifth item, @racket[_out-k], it is used
    a hint for the number of files to use for the document's
@@ -444,9 +452,13 @@ Optional @filepath{info.rkt} fields trigger additional actions by
     ]
 
     The @racket[_category] list specifies how to show the document in
-    the root table of contents. The list must start with a symbol,
+    the root table of contents. The list must start with a category,
-    usually one of the following categories, which are ordered as
+    which determines where the manual appears in the root
-    below in the root documentation page:
+    documentation page. A category is either a string or a symbol. If
+    it is a string, then the string is the category label on the root
+    page. If it is a symbol, then a default category label is
+    used. The available symbols and the order of categories on the
+    root documentation page is as below:
 
    @itemize[
 
@@ -475,6 +487,8 @@ Optional @filepath{info.rkt} fields trigger additional actions by
      @item{@racket['interop] : Documentation for interoperability
            tools and libraries.}
 
+     @item{All string categories as ordered by @racket[string<=?].}
+     
      @item{@racket['library] : Documentation for libraries; this
            category is the default and used for unrecognized category
            symbols.}
@@ -528,7 +542,10 @@ Optional @filepath{info.rkt} fields trigger additional actions by
    source file need not be present. Moving documentation into place
    may require no movement at all, depending on the way that the
    enclosing collection is installed, but movement includes adding a
-   @filepath{synced.rktd} file to represent the installation.}
+   @filepath{synced.rktd} file to represent the installation.
+
+   @history[#:changed "6.4" @elem{Allow a category to be a string
+                                 instead of a symbol.}]}
 
  @item{@as-index{@racketidfont{release-note-files}} : @racket[(listof (cons/c string? (cons/c string? list?)))] ---
    A list of release-notes text files to link from the main documentation pages.
@@ -639,7 +656,7 @@ Optional @filepath{info.rkt} fields trigger additional actions by
 
    On Windows, deleting a previously installed foreign library may be
    complicated by a lock on the file, if it is in use. To compensate,
-   @exec{raco setup} deletes a foriegn-library file by first renaming
+   @exec{raco setup} deletes a foreign-library file by first renaming
    the file to have the prefix @filepath{raco-setup-delete-}; it then
    attempts to delete the renamed file and merely issues a warning on
    a failure to delete the renamed file. Meanwhile, in modes where
@@ -753,6 +770,13 @@ Optional @filepath{info.rkt} fields trigger additional actions by
    file, etc. Supplying a specific list of collections to @exec{raco
    setup} disables this dependency-based deletion of compiled files.}
 
+ @item{@racket[compile-omit-paths], @racket[compile-omit-files], and
+   @racket[compile-include-files] --- Used indirectly via
+   @racket[compile-collection-zos].}
+
+@item{@racket[module-suffixes] and @racket[doc-module-suffixes] ---
+   Used indirectly via @racket[get-module-suffixes].}
+
 ]
 
 @; ------------------------------------------------------------------------
@@ -1207,7 +1231,7 @@ function for installing a single @filepath{.plt} file.
   @envvar{PLTCOLLECTS} setting or change to the parameter may cause
   them to be omitted. Any other path in
   @racket[(current-library-collection-paths)] is treated as
-  user-specific. The dierctories indicated by the returned paths may
+  user-specific. The directories indicated by the returned paths may
   or may not exist.}
 
 @defproc[(find-config-dir) (or/c path? #f)]{
@@ -1280,7 +1304,7 @@ function for installing a single @filepath{.plt} file.
 @defproc[(get-lib-search-dirs) (listof path?)]{
   Returns a list of paths to search for foreign libraries. Unless it is
   configured otherwise, the result includes any non-@racket[#f] result of
-  @racket[(find-lib-dir)] and
+  @racket[(find-lib-dir)]
   and @racket[(find-user-lib-dir)]---but the latter is included only if the
   value of the @racket[use-user-specific-search-paths] parameter
   is @racket[#t].
@@ -1526,7 +1550,7 @@ function for installing a single @filepath{.plt} file.
 The Racket installation tree can usually be moved around the filesystem.
 To support this, care must be taken to avoid absolute paths.  The
 following two APIs cover two aspects of this: a way to convert a path to
-a value that is relative to the @filepath{collets} tree, and a way to
+a value that is relative to the @filepath{collects} tree, and a way to
 display such paths (e.g., in error messages).
 
 @subsection{Representing Collection-Based Paths}
@@ -1559,7 +1583,7 @@ is a pair that starts with @racket['collects], then it is converted
 back to a path using @racket[collection-file-path].}
 
 @defproc[(path->module-path [path path-string?]
-                            [#:cache cache (or/c #f (and/c hash? (not/c imutable?)))])
+                            [#:cache cache (or/c #f (and/c hash? (not/c immutable?)))])
          (or/c path-string? module-path?)]{
 
 Like @racket[path->collects-relative], but the result is either
@@ -1709,6 +1733,50 @@ is not the ASCII value of a letter, digit, @litchar{-}, @litchar{+},
 or @litchar{_}.}
 
 
+@; ------------------------------------------------------------------------
+
+@section[#:tag "collection-search"]{API for Collection Searches}
+
+@defmodule[setup/collection-search]
+
+@history[#:added "6.3"]
+
+@defproc[(collection-search [mod-path normalized-lib-module-path?]
+                            [#:init result any/c #f]
+                            [#:combine combine (any/c (and/c path? complete-path?) . -> . any/c) (lambda (r v) v)]
+                            [#:break? break? (any/c . -> . any/c) (lambda (r) #f)]
+                            [#:all-possible-roots? all-possible-roots? any/c #f])
+         any/c]{
+
+Generalizes @racket[collection-file-path] to support folding over all
+possible locations of a collection-based file in the current
+configuration. Unlike @racket[collection-file-path],
+@racket[collection-search] takes the file to location in module-path
+form, but always as a @racket['lib] path.
+
+Each possible path for the file (not counting a @filepath{.ss} to/from
+@filepath{.rkt} conversion) is provided as a second argument to the
+@racket[combine] function, where the first argument is the current
+result, and the value produced by @racket[combine] becomes the new
+result. The @racket[#:init] argument provides the initial result.
+
+The @racket[break?] function short-circuits a search based on the
+current value. For example, it could be used to short-circuit a search
+after a suitable path is found.
+
+If @racket[all-possible-roots?] is @racket[#f], then @racket[combine]
+is called only on paths within @filepath{collects}-like directories
+(for the current configuration) where at least a matching collection
+directory exists.}
+
+
+@defproc[(normalized-lib-module-path? [v any/c]) boolean?]{
+
+Returns @racket[#t] if @racket[v] is a module path (in the sense of
+@racket[module-path?]) of the form @racket['(lib _str)] where
+@racket[_str] contains at least one slash. The
+@racket[collapse-module-path] function produces such module paths for
+collection-based module references.}
 
 @; ------------------------------------------------------------------------
 
@@ -1724,9 +1792,14 @@ Returns @racket[#t] if @racket[v] is a symbol, string, or regexp value
 (in the sense of @racket[regexp?]), @racket[#f] otherwise.}
 
 @defproc[(matching-platform? [spec platform-spec?]
-                             [#:system-type sys-type (or/c #f symbol?) (system-type)]
+                             [#:cross? cross? any/c #f]
-                             [#:system-library-subpath sys-lib-subpath (or/c #f path?)
+                             [#:system-type sys-type (or/c #f symbol?) (if cross?
-                                                       (system-library-subpath #f)])
+                                                                           (cross-system-type)
+                                                                           (system-type))]
+                             [#:system-library-subpath sys-lib-subpath (or/c #f path-for-some-system?)
+                                                       (if cross?
+                                                           (cross-system-library-subpath #f)
+                                                           (system-library-subpath #f))])
          boolean?]{
 
 Reports whether @racket[spec] matches @racket[sys-type] or
@@ -1742,8 +1815,74 @@ If @racket[spec] is a string, then the result is @racket[#t] if
 
 If @racket[spec] is a regexp value, then the result is @racket[#t] if
 the regexp matches @racket[(path->string sys-lib-subpath)],
+@racket[#f] otherwise.
+
+@history[#:changed "6.3" @elem{Added @racket[#:cross?] argument and
+                                      changed the contract on @racket[sys-lib-subpath]
+                                      to accept @racket[path-for-some-system?]
+                                      instead of just @racket[path?].}]}
+
+@; ------------------------------------------------------------------------
+
+@section[#:tag "cross-system"]{API for Cross-Platform Configuration}
+
+@defmodule[setup/cross-system]{The @racketmodname[setup/cross-system]
+library provides functions for querying the system properties of a
+destination platform, which can be different than the current platform
+in cross-installation modes.}
+
+A Racket installation includes a @filepath{system.rktd} file in the
+directory reported by @racket[(find-lib-dir)]. When the information in that file
+does not match the running Racket's information, then the
+@racketmodname[setup/cross-system] module infers that Racket is being
+run in cross-installation mode.
+
+For example, if an in-place Racket installation for a different
+platform resides at @nonterm{cross-dir}, then
+
+@commandline{racket -G @nonterm{cross-dir}/etc -X @nonterm{cross-dir}/collects -l- raco pkg}
+
+runs @exec{raco pkg} using the current platform's @exec{racket}
+executable, but using the collections and other configuration
+information of @nonterm{cross-dir}, as well as modifying the packages
+of @nonterm{cross-dir}. That can work as long as no platform-specific
+libraries need to run to perform the requested @exec{raco pkg} action
+(e.g., when installing built packages).
+
+
+@history[#:added "6.3"]
+
+@defproc[(cross-system-type [mode (or/c 'os 'word 'gc 'link 'machine
+                                        'so-suffix 'so-mode 'fs-change)
+                            'os])
+         (or/c symbol? string? bytes? exact-positive-integer? vector?)]{
+
+Like @racket[system-type], but for the target platform instead of the
+current platform in cross-installation mode. When not in
+cross-installation mode, the results are the same as for
+@racket[system-type].}
+
+
+@defproc[(cross-system-library-subpath [mode (or/c 'cgc '3m #f)
+                                             (system-type 'gc)])
+         path-for-some-system?]{
+
+Like @racket[system-library-subpath], but for the target platform
+instead of the current platform in cross-installation mode. When not
+in cross-installation mode, the results are the same as for
+@racket[system-library-subpath].
+
+In cross-installation mode, the target platform may have a different
+path convention than the current platform, so the result is
+@racket[path-for-some-system?] instead of @racket[path?].}
+
+
+@defproc[(cross-installation?) boolean?]{
+
+Returns @racket[#t] if cross-installation mode has been detected,
 @racket[#f] otherwise.}
 
+
 @; ------------------------------------------------------------------------
 
 @section[#:tag "xref"]{API for Cross-References for Installed Manuals}

pkgs/racket-doc/scribblings/raco/test.scrbl

@@ -5,7 +5,8 @@
           (for-label racket/runtime-path
                      racket/base
                      launcher/launcher
-                     rackunit/log))
+                     rackunit/log
+                     compiler/module-suffix))
 
 @title[#:tag "test"]{@exec{raco test}: Run tests}
 
@@ -19,12 +20,14 @@ the file.
 
 When an argument path refers to a directory, @exec{raco test}
 recursively discovers and runs all files within the directory that end
-in @filepath{.rkt}, end in @filepath{.scrbl}, or have a (possibly
+in a module suffix (see @racket[get-module-suffixes], but the suffixes
-empty) list of command-line arguments provided by
+always include @filepath{.rkt}, @filepath{.scrbl}, @filepath{.ss}, and
-@racket[test-command-line-arguments] in an @filepath{info.rkt} file.
+@filepath{.scm}) or have a (possibly empty) list of command-line arguments provided by
-At the same time, @exec{raco test} omits files and directories within
+@racket[test-command-line-arguments] in an @filepath{info.rkt} file,
-a directory as directed by @racket[test-omit-paths] in an
+or as directed by @racket[test-include-paths] in an
-@filepath{info.rkt} file.
+@filepath{info.rkt} file.  At the same time, @exec{raco test} omits
+files and directories within a directory as directed by
+@racket[test-omit-paths] in an @filepath{info.rkt} file.
 
 A test is counted as failing if it logs a failing test code via
 @racket[test-log!], causes Racket to exit with a non-zero exit code, or
@@ -52,11 +55,11 @@ The @exec{raco test} command accepts several flags:
        --- Not only interprets the arguments as paths (which is the
        default mode), but treats them the same as paths found in a
        directory, which means ignoring a file argument that does not
-       have the extension @filepath{.rkt}, does not have the extension
+       have a module extension or is not enabled explicitly via
-       @filepath{.scrbl}, or is not enabled explicitly via
+       @racket[test-command-line-arguments] or @racket[test-include-paths]
-       @racket[test-command-line-arguments] in an @filepath{info.rkt}
+       in an @filepath{info.rkt} file; meanwhile, paths that are otherwise
-       file; meanwhile, paths that are otherwise enabled can be disabled
+       enabled can be disabled via @racket[test-omit-paths] in an
-       via @racket[test-omit-paths] in an @filepath{info.rkt} file.}
+       @filepath{info.rkt} file.}
 
  @item{@DFlag{drdr}
        --- Configures defaults to imitate the DrDr continuous testing
@@ -86,6 +89,14 @@ The @exec{raco test} command accepts several flags:
        --- When multiple submodule names are provided with @Flag{s} or
        @DFlag{submodule}, runs only the first available submodule.}
 
+@item{@DFlag{configure-runtime}
+       --- Run a @racketidfont{configure-runtime} submodule (if any) of
+       each specified module before the module or a
+       submodule is run. This mode is the default when only a single
+       module is provided or when @DFlag{process} or @DFlag{place}
+       mode is specified, unless a submodule name is provided
+       via @Flag{s} or @DFlag{submodule}.}
+
  @item{@DFlag{direct}
       --- Runs each test in a thread. This mode is the default if
       a single file is specified. Multiple tests can interfere with
@@ -151,7 +162,9 @@ The @exec{raco test} command accepts several flags:
 
 ]
 
-@history[#:changed "1.1" @elem{Added @DFlag{heartbeat}.}]
+@history[#:changed "1.1" @elem{Added @DFlag{heartbeat}.}
+         #:changed "1.4" @elem{Changed recognition of module suffixes to use @racket[get-module-suffixes],
+                               which implies recognizing @filepath{.ss} and @filepath{.rkt}.}]
 
 @section[#:tag "test-config"]{Test Configuration by Submodule}
 
@@ -212,20 +225,29 @@ impossible (e.g., because the file will not always compile). Thus,
 @exec{raco test} also consults any @filepath{info.rkt} file in the
 candidate test file's directory. In the case of a file within a
 collection, @filepath{info.rkt} files from any enclosing collection
-directories are also consulted for @racket[test-omit-paths]. Finally,
+directories are also consulted for @racket[test-omit-paths] and
-for a file within a package, the package's @filepath{info.rkt} is
+@racket[test-include-paths]. Finally, for a file within a package, the
-consulted for @racket[pkg-authors] to set the default responsible
+package's @filepath{info.rkt} is consulted for @racket[pkg-authors] to
-parties (see @secref["test-responsible"]) for all files in the
+set the default responsible parties (see @secref["test-responsible"])
-package.
+for all files in the package.
 
 The following @filepath{info.rkt} fields are recognized:
 
 @itemlist[
 
  @item{@racket[test-omit-paths] --- a list of path strings (relative
-       to the enclosing directory) or @racket['all] to omit all files
+       to the enclosing directory) and regexp values (to omit all
-       within the enclosing directory.  When a path string refers to a
+       files within the enclosing directory matching the expression),
-       directory, all files within the directory are omitted.}
+       or @racket['all] to omit all files within the enclosing directory.
+       When a path string refers to a directory, all files within the
+       directory are omitted.}
+
+ @item{@racket[test-include-paths] --- a list of path strings (relative
+       to the enclosing directory) and regexp values (to include all
+       files within the enclosing directory matching the expression),
+       or @racket['all] to include all files within the enclosing directory.
+       When a path string refers to a directory, all files within the
+       directory are included.}
       
  @item{@racket[test-command-line-arguments] --- a list of
        @racket[(list _module-path-string (list _argument-path-string
@@ -254,6 +276,9 @@ The following @filepath{info.rkt} fields are recognized:
        the enclosing directory) for modules whose output varies.
        See @secref["test-responsible"].}
 
+ @item{@racket[module-suffixes] and @racket[doc-module-suffixes] ---
+       Used indirectly via @racket[get-module-suffixes].}
+
 ]
 
 @section[#:tag "test-responsible"]{Responsible-Party and Varying-Output Logging}

pkgs/racket-doc/scribblings/raco/zo-parse.scrbl

@@ -75,3 +75,12 @@ The @racketmodname[compiler/zo-parse] module re-exports
   or @racket[mod] structure indicates the list of global variables and
   quoted syntax that need to be instantiated (and put into an array on
   the stack) before evaluating expressions that might use them.}
+
+
+@defproc[(decode-module-binding [binding module-binding?]
+                                [name symbol?])
+         decoded-module-binding?]{
+
+Given a compact-form representation of a module binding and the name
+from which the binding is mapped, returns a normalized form of the
+binding.}

pkgs/racket-doc/scribblings/raco/zo-struct.scrbl

@@ -1,5 +1,6 @@
 #lang scribble/doc
 @(require scribble/manual
+          scribble/core
           (for-label racket/base
                      racket/contract
                      compiler/zo-structs
@@ -19,6 +20,14 @@ The @racketmodname[compiler/zo-structs] library defines the bytecode
 structures that are produced by @racket[zo-parse] and consumed by
 @racket[decompile] and @racket[zo-marshal].
 
+@nested[#:style 'inset]{
+@elem[#:style (style #f (list (background-color-property "yellow")))]{@bold{Warning:}}
+      The @racketmodname[compiler/zo-structs] library exposes internals
+      of the Racket bytecode abstraction. Unlike other Racket
+      libraries, @racketmodname[compiler/zo-structs] is subject to
+      incompatible changes across Racket versions.}
+
+
 @defstruct+[zo ()]{
   A supertype for all forms that can appear in compiled code.}
 
@@ -27,21 +36,35 @@ structures that are produced by @racket[zo-parse] and consumed by
 
 @defstruct+[(compilation-top zo)
             ([max-let-depth exact-nonnegative-integer?]
+             [binding-namess (hash/c exact-nonnegative-integer?
+                                     (hash/c symbol? stx?))]
              [prefix prefix?]
              [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
-  @racket[prefix] array).  The @racket[prefix] field describes top-level
+  @racket[prefix] array).
-  variables, module-level variables, and quoted syntax-objects accessed
+
-  by @racket[code].  The @racket[code] field contains executable code;
+  The @racket[binding-namess] field provides a per-phase mapping from
-  it is normally a @racket[form], but a literal value is represented as
+  symbols that appear in @racket[prefix] for top-level
-  itself.}
+  @racket[def-values] forms and in top-level @racket[def-syntaxes]
+  forms. Each symbol is mapped to an identifier that will be bound
+  (after introduction into the namespace) by the definition.
+
+  The @racket[prefix] field describes top-level variables,
+  module-level variables, and quoted syntax-objects accessed by
+  @racket[code].
+
+  The @racket[code] field contains executable code; it is normally a
+  @racket[form], but a literal value is represented as itself.}
 
 @defstruct+[(prefix zo)
             ([num-lifts exact-nonnegative-integer?]
              [toplevels (listof (or/c #f symbol? global-bucket?
                                       module-variable?))]
-             [stxs (listof stx?)])]{
+             [stxs (listof (or stx? #f))]
+             [src-inspector-desc symbol?])]{
   Represents a ``prefix'' that is pushed onto the stack to initiate
   evaluation.  The prefix is an array, where buckets holding the
   values for @racket[toplevels] are first, then the buckets for the
@@ -63,7 +86,16 @@ structures that are produced by @racket[zo-parse] and consumed by
 
   The variable buckets and syntax objects that are recorded in a prefix
   are accessed by @racket[toplevel] and @racket[topsyntax] expression
-  forms.}
+  forms.
+  
+  When an element of @racket[stxs] is @racket[#f], it coresponds to a
+  syntax object that was optimized away at the last minute. The slot
+  must not be referenced vt a @racket[topsyntax] form.
+
+  The @racket[src-inspector-desc] field provides an inspector name that
+  is used within syntax-object bindings. At run time, the prefix gets
+  an inspector, and bindings that reference the same inspector name are
+  granted access capabilities through that inspector.}
 
 @defstruct+[(global-bucket zo) ([name symbol?])]{
   Represents a top-level variable, and used only in a @racket[prefix].}
@@ -111,8 +143,8 @@ returns.}
 Represents the shape of an expected import as a structure-type
 binding, constructor, etc.}
 
-@defstruct+[(stx zo) ([encoded wrapped?])]{
+@defstruct+[(stx zo) ([content stx-obj?])]{
-  Wraps a syntax object in a @racket[prefix].}
+  Wraps a syntax object as it appears in a @racket[prefix].}
 
 
 @; --------------------------------------------------
@@ -205,6 +237,8 @@ binding, constructor, etc.}
              [dummy toplevel?]
              [lang-info (or/c #f (vector/c module-path? symbol? any/c))]
              [internal-context (or/c #f #t stx? (vectorof stx?))]
+             [binding-names (hash/c exact-integer?
+                                    (hash/c symbol? (or/c #t stx?)))]
              [flags (listof (or/c 'cross-phase))]
              [pre-submodules (listof mod?)]
              [post-submodules (listof mod?)])]{
@@ -240,12 +274,24 @@ binding, constructor, etc.}
   The @racket[lang-info] value specifies an optional module path that
   provides information about the module's implementation language.
 
-  The @racket[internal-module-context] value describes the lexical
+  The @racket[internal-context] value describes the lexical context of
-  context of the body of the module.  This value is used by
+  the body of the module. This value is used by
   @racket[module->namespace]. A @racket[#f] value means that the
   context is unavailable or empty. A @racket[#t] value means that the
   context is computed by re-importing all required modules. A
-  syntax-object value embeds an arbitrary lexical context.
+  syntax-object value embeds lexical information; the syntax object
+  should contain a vector of two elements, where the first element of
+  the vector is a syntax object for the module's body, which includes
+  the outside-edge and inside-edge scopes, and the second element of
+  the vector is a syntax object that has just the module's inside-edge
+  scope.
+
+  The @racket[binding-names] value provides additional information to
+  @racket[module->namespace] to correlate symbol names for variables
+  and syntax definitions to identifiers that map to those variables. A
+  separate table of names exists for each phase, and a @racket[#t]
+  mapping for a name indicates that it is mapped but inaccessible
+  (because the relevant scopes are inaccessible).
 
   The @racket[flags] field records certain properties of the module.
   The @racket['cross-phase] flag indicates that the module body is
@@ -257,7 +303,7 @@ binding, constructor, etc.}
   submodules, while the @racket[post-submodules] field records
   @racket[module*]-declared submodules.}
 
-@defstruct+[provided
+@defstruct+[(provided zo)
             ([name symbol?]
              [src (or/c module-path-index? #f)]
              [src-name symbol?]
@@ -307,7 +353,7 @@ binding, constructor, etc.}
   values; also, this information is redundant, since it can be inferred
   by the bindings referenced though @racket[closure-map].
 
-  Which a closure captures top-level or module-level variables or
+  When a closure captures top-level or module-level variables or
   refers to a syntax-object constant, the variables and constants are
   represented in the closure by capturing a prefix (in the sense
   of @racket[prefix]).  The @racket[toplevel-map] field indicates
@@ -539,6 +585,22 @@ binding, constructor, etc.}
   which is handled specially by the run-time system.}
 
 
+@defstruct+[(with-immed-mark expr)
+            ([key (or/c expr? seq? any/c)]
+             [val (or/c expr? seq? any/c)]
+             [body (or/c expr? seq? any/c)])]{
+
+  Represents a @racket[(call-with-immediate-continuation-mark key
+  (lambda (_arg) _body) val)] expression that is handled specially by
+  the run-time system to avoid a closure allocation. One initialized
+  slot is pushed onto the stack after @racket[expr] and @racket[val]
+  are evaluated and before @racket[body] is evaluated.
+
+  After each of @racket[key] and @racket[val] is evaluated, the stack is
+  restored to its depth from before evaluating @racket[key] or
+  @racket[val].}
+
+
 @defstruct+[(primval expr)
             ([id exact-nonnegative-integer?])]{
   Represents a direct reference to a variable imported from the run-time
@@ -547,127 +609,207 @@ binding, constructor, etc.}
 @; --------------------------------------------------
 @section{Syntax Objects}
 
-@defstruct+[(wrapped zo)
+@defstruct+[(stx-obj zo)
             ([datum any/c]
-             [wraps (listof wrap?)]
+             [wrap wrap?]
+             [srcloc (or/c #f srcloc?)]
+             [props (hash/c symbol? any/c)]
              [tamper-status (or/c 'clean 'armed 'tainted)])]{
-  Represents a syntax object, where @racket[wraps] contain the lexical
+  Represents a syntax object, where @racket[wrap] contains lexical
-  information and @racket[tamper-status] is taint information. When the
+  information, @racket[srcloc] is the source location,
-  @racket[datum] part is itself compound, its pieces are wrapped, too.}
+  @racket[props] contains preserved properties,
+  and @racket[tamper-status] is taint information. When the
+  @racket[datum] part is itself compound, its pieces are wrapped
+  as @racket[stx-obj]s, too.
 
-@defstruct+[(wrap zo) ()]{
+  The content of @racket[wrap] is typically cyclic, since it includes
-  A supertype for lexical-information elements.}
+  scopes that contain bindings that refer to scopes.}
 
-@defstruct+[(top-level-rename wrap) ([flag boolean?])]{
+@defstruct+[(wrap zo) ([shifts (listof module-shift?)]
-  A top-level renaming.}
+                       [simple-scopes (listof scope?)]
+                       [multi-scopes (listof (list/c multi-scope? (or/c #f exact-integer?)))])]{
+  Lexical information for a syntax object. The @racket[shifts] field
+  allows binding information to be relative to the enclosing module's
+  run-time path. The @racket[simple-scopes] field records scopes that
+  are attached to the syntax object at all phases, and @racket[multi-scopes]
+  records phase-specific scopes (which are always attached as a group)
+  along with a phase shift for every scope within the group).}
 
-@defstruct+[(mark-barrier wrap) ([value symbol?])]{
+@defstruct+[(module-shift zo) ([from (or/c #f module-path-index?)]
-  A mark barrier.}
+                               [to (or/c #f module-path-index?)]
+                               [from-inspector-desc (or/c #f symbol?)]
+                               [to-inspector-desc (or/c #f symbol?)])]{
 
-@defstruct+[(free-id-info zo)
+Records a history of module path index replacements. These replacements
-            ([path0 module-path-index?]
+are applied in reverse order, and a module instantiation typically adds
-             [symbol0 symbol?]
+one more shift to replace the current ``self'' module path index
-             [path1 module-path-index?]
+with a run-time module path. The @racket[from] and @racket[to]
-             [symbol1 symbol?]
+fields should be both @racket[#f] or both non-@racket[#f].
-             [phase0 (or/c exact-integer? #f)]
-             [phase1 (or/c exact-integer? #f)]
-             [phase2 (or/c exact-integer? #f)]
-             [use-current-inspector? boolean?])]{
-  Information about a free identifier.}
 
-@defstruct+[(lexical-rename wrap)
+The @racket[from-inspector-desc] and @racket[to-inspector-desc] fields
-            ([has-free-id-info? boolean?]
+similarly should be both @racket[#f] or both non-@racket[#f]. They
-             [bool2 boolean?]
+record a history of code-inspector replacements.}
-             [alist
-              (listof
-               (cons/c symbol?
-                       (or/c symbol?
-                             (cons/c symbol?
-                                     (or/c (cons/c symbol? (or/c symbol? #f))
-                                           free-id-info?)))))])]{
-  A local-binding mapping from symbols to binding-set names.}
 
 
-@defstruct+[(phase-shift wrap)
+@defstruct+[(scope zo) ([name (or/c 'root exact-nonnegative-integer?)]
-            ([amt (or/c exact-integer? #f)]
+                        [kind symbol?]
-             [src module-path-index?]
+                        [bindings (listof (list/c symbol? (listof scope?) binding?)) #;#:mutable]
-             [dest module-path-index?]
+                        [bulk-bindings (listof (list/c (listof scope?) all-from-module?)) #;#:mutable]
-             [cancel-id (or/c exact-integer? #f)])]{
+                        [multi-owner (or/c #f multi-scope?) #;#:mutable])]{
-  Shifts module bindings later in the wrap set.}
 
-@defstruct+[(module-rename wrap)
+Represents a scope. When @racket[name] is @racket['root] then the
-            ([phase exact-integer?]
+scope represents the unique all-phases scope that is shared among
-             [kind (or/c 'marked 'normal)]
+non-module namespaces. Otherwise, @racket[name] is intended to be
-             [set-id any/c]
+distinct for each @racket[scope] instance within a module or top-level
-             [unmarshals (listof make-all-from-module?)]
+compilation, but the @racket[eq?]-identity of the @racket[scope]
-             [renames (listof module-binding?)]
+instance ultimately determines its identity. The @racket[kind] symbol
-             [mark-renames any/c]
+similarly acts as a debugging hint in the same way as for
-             [plus-kern? boolean?])]{
+@racket[syntax-debug-info].
-  Represents a set of module and import bindings.}
 
-@defstruct+[(all-from-module zo)
+The @racket[bindings] list indicates some bindings that are associated
-            ([path module-path-index?]
+with the scope. Each element of the list includes a symbolic name, a
+list of scopes (including the enclosing one), and the binding for the
+combination of name and scope set. A given symbol can appear in
+multiple elements of @racket[bindings], but the combination of the
+symbol and scope set are unique within @racket[bindings] and across
+all scopes. The mapping of a symbol and scope set to a binding is
+recorded with an arbitrary member of the scope set.
+
+The @racket[bulk-bindings] field lists bindings of all exports from a
+given module, which is an optimization over including each export in
+@racket[bindings]. Elements of @racket[bindings] take precedence over
+elements of @racket[bulk-bindings], and earlier elements of
+@racket[bulk-bindings] take precedence over later elements.
+
+If the @racket[scope] represents a scope at a particular phase for a
+group of phase-specific scopes, @racket[mark-owner] refers to the
+group.}
+
+
+@defstruct+[(multi-scope zo) ([name exact-nonnegative-integer?]
+                              [src-name any/c]
+                              [scopes (listof (list/c (or/c #f exact-integer?) scope?)) #;#:mutable])]{
+
+Represents a set of phase-specific scopes that are added or removed
+from lexical information as a group. As for @racket[scope], the
+@racket[name] field is intended to be distinct for different groups,
+but the @racket[eq?] identity of the @racket[multi-scope] record
+ultimately determines its identity. The @racket[src-name] field
+similarly acts as a debugging hint in the same way as for
+@racket[syntax-debug-info].
+
+Scopes within the group are instantiated at different phases on
+demand. The @racket[scopes] field lists all of the scopes instantiated
+for the group, and the phase at which it is instantiated. Each element
+of @racket[scopes] must have a @racketidfont{multi-owner} field
+value that refers back to the @racket[multi-scope].}
+
+
+@defstruct+[(binding zo) ()]{
+
+A supertype for all binding representations.}
+
+
+@defstruct+[(module-binding binding) ([encoded any/c])]{
+
+Represents a binding to a module or top-level definition. The
+@racket[encoded] field can be unpacked using
+@racket[decode-module-binding], providing the symbol name for which
+the binding is the target (since @racket[encoded] can be relative to
+that name).}
+
+
+@defstruct+[(decoded-module-binding binding) ([path (or/c #f module-path-index?)]
+                                              [name symbol?]
+                                              [phase exact-integer?]
+                                              [nominal-path (or/c #f module-path-index?)]
+                                              [nominal-export-name symbol?]
+                                              [nominal-phase (or/c #f exact-integer?)]
+                                              [import-phase (or/c #f exact-integer?)]
+                                              [inspector-desc (or/c #f symbol?)])]{
+
+Represents a binding to a module or top-level definition---like
+@racket[module-binding], but in normalized form:
+
+@itemlist[
+
+ @item{@racket[path]: the referenced module.}
+
+ @item{@racket[name]: the referenced definition within its module.}
+
+ @item{@racket[phase]: the phase of the referenced definition within
+       its module.}
+
+ @item{@racket[nominal-path]: the module that was explicitly imported
+       into the binding context; this path can be different from
+       @racket[path] when a definition is re-exported.}
+
+ @item{@racket[nominal-export-name]: the name of the binding as
+       exported from @racket[nominal-path], which can be different from
+       @racket[name] due to renaming on export.}
+
+ @item{@racket[nominal-phase]: the phase of the export from
+       @racket[nominal-path], which can be different from @racket[phase]
+       due to re-export from a module that imports at a phase level other
+       than @racket[0].}
+
+ @item{@racket[import-phase]: the phase of the import of
+       @racket[nominal-path], which shifted (if non-@racket[0]) the
+       binding phase relative to the export phase from
+       @racket[nominal-path].}
+
+ @item{@racket[inspector-desc]: a name for an inspector (mapped to a
+       specific inspector at run time) that determines access to the
+       definition.}
+
+]}
+
+@defstruct+[(local-binding binding) ([name symbol?])]{
+
+Represents a local binding (i.e., not at the top level or module level).
+Such bindings rarely appear in bytecode, since @racket[quote-syntax]
+prunes them.}
+
+
+@defstruct+[(free-id=?-binding binding) ([base (and/c binding?
+                                                      (not/c free-id=?-binding?))]
+                                         [id stx-obj?]
+                                         [phase (or/c #f exact-integer?)])]{
+
+Represents a binding that includes a @racket[free-identifier=?] alias
+(to an identifier with a particular phase shift) as well as a base binding.}
+
+
+@defstruct+[(all-from-module zo) ([path module-path-index?] 
                                   [phase (or/c exact-integer? #f)] 
                                   [src-phase (or/c exact-integer? #f)]
+                                  [inspector-desc symbol?]
                                   [exceptions (listof symbol?)]
-             [prefix (or/c symbol? #f)]
+                                  [prefix (or/c symbol? #f)])]{
-             [context (or/c (listof exact-integer?) 
-                            (vector/c (listof exact-integer?) any/c) 
-                            #f)])]{
-  Represents a set of simple imports from one module within a
-  @racket[module-rename].}
 
-@defstruct+[(module-binding zo) ()]{
+Describes a bulk import as an optimization over individual imports of
-  A supertype for module bindings.}
+a module's exports:
 
-@defstruct+[(simple-module-binding module-binding)
+@itemlist[
-            ([path module-path-index?])]{
-  Represents a single identifier import within a
-  @racket[module-rename].}
 
-@defstruct+[(phased-module-binding module-binding)
+ @item{@racket[path]: the imported module.}
-            ([path module-path-index?]
-             [phase exact-integer?]
-             [export-name any/c]
-             [nominal-path nominal-path?]
-             [nominal-export-name any/c])]{
-  Represents a single identifier import within a
-  @racket[module-rename].}
  
-@defstruct+[(exported-nominal-module-binding module-binding)
+ @item{@racket[phase]: the phase of the import module's exports.}
-            ([path module-path-index?]
-             [export-name any/c]
-             [nominal-path nominal-path?]
-             [nominal-export-name any/c])]{
-  Represents a single identifier import within a
-  @racket[module-rename].}
 
-@defstruct+[(nominal-module-binding module-binding)
+ @item{@racket[src-phase]: the phase at which @racket[path] was
-            ([path module-path-index?]
+       imported; @racket[src-phase] combined with @racket[phase]
-             [nominal-path nominal-path?])]{
+       determines the phase of the bindings.}
-  Represents a single identifier import within a
-  @racket[module-rename].}
 
-@defstruct+[(exported-module-binding module-binding)
+ @item{@racket[inspector-desc]: a name for an inspector (mapped to a
-            ([path module-path-index?]
+       specific inspector at run time) that determines access to the
-             [export-name any/c])]{
+       definition.}
-  Represents a single identifier import within a
-  @racket[module-rename].}
 
-@defstruct+[(nominal-path zo) ()]{
+ @item{@racket[exceptions]: exports of @racket[path] that are omitted
-  A supertype for nominal paths.}
+       from the bulk import.}
  
-@defstruct+[(simple-nominal-path nominal-path)
+ @item{@racket[prefix]: a prefix, if any, applied (after
-            ([value module-path-index?])]{
+       @racket[exceptions]) to each of the imported names.}
-  Represents a simple nominal path.}
+
+]}
 
-@defstruct+[(imported-nominal-path nominal-path)
-            ([value module-path-index?]
-             [import-phase exact-integer?])]{
-  Represents an imported nominal path.}
  
-@defstruct+[(phased-nominal-path nominal-path)
-            ([value module-path-index?]
-             [import-phase (or/c false/c exact-integer?)]
-             [phase exact-integer?])]{
-  Represents a phased nominal path.}

pkgs/racket-doc/scribblings/reference/async-channels.scrbl

@@ -70,8 +70,9 @@ synchronization} when @racket[(async-channel-put ach v)] would return
 a value (i.e., when the channel holds fewer values already than its
 limit); @resultItself{asychronous channel-put event}.}
 
-@defexamples[#:eval (async-eval)
+@examples[#:eval (async-eval) #:once
-(define (server input-channel output-channel)
+(eval:no-prompt
+ (define (server input-channel output-channel)
    (thread (lambda ()
              (define (get)
                (async-channel-get input-channel))
@@ -88,9 +89,8 @@ limit); @resultItself{asychronous channel-put event}.}
                  [(long) (begin
                            (put (do-large-computation))
                            (loop (get)))])))))
-
+ (define to-server (make-async-channel))
-(define to-server (make-async-channel))
+ (define from-server (make-async-channel)))
-(define from-server (make-async-channel))
 
 (server to-server from-server)
 

pkgs/racket-doc/scribblings/reference/block.scrbl

@@ -1,5 +1,5 @@
 #lang scribble/doc
-@(require "mz.rkt" scribble/eval (for-label racket/block))
+@(require "mz.rkt" (for-label racket/block))
 
 @(define ev (make-base-eval))
 @(ev '(require racket/block))

pkgs/racket-doc/scribblings/reference/bytes.scrbl

@@ -643,7 +643,7 @@ normally identified by @racket[""]). See also
 @section{Additional Byte String Functions}
 @note-lib[racket/bytes]
 @(define string-eval (make-base-eval))
-@(interaction-eval #:eval string-eval (require racket/bytes racket/list))
+@@examples[#:hidden #:eval string-eval (require racket/bytes racket/list)]
 
 @defproc[(bytes-append* [str bytes?] ... [strs (listof bytes?)]) bytes?]{
 @; Note: this is exactly the same description as the one for append*

pkgs/racket-doc/scribblings/reference/channels.scrbl

@@ -15,10 +15,9 @@ often, then the thread eventually participates in a transaction.
 
 In addition to its use with channel-specific procedures, a channel can
 be used as a @tech{synchronizable event} (see @secref["sync"]).  A
-channel is @tech{ready for synchronization} when @racket[make-channel]
+channel is @tech{ready for synchronization} when @racket[channel-get]
-is ready when @racket[channel-get] would not block; the channel's
+would not block; the channel's @tech{synchronization result} is the
-@tech{synchronization result} is the same as the @racket[channel-get]
+same as the @racket[channel-get] result.
-result.
 
 For buffered asynchronous channels, see @secref["async-channel"].
 

pkgs/racket-doc/scribblings/reference/chaperones.scrbl

@@ -191,18 +191,31 @@ required keyword arguments of @racket[wrapper-proc] must be a subset
 of the required keywords of @racket[proc].
 
 For applications without keywords, the result of @racket[wrapper-proc]
-must be either the same number of values as supplied to it or one more
+must be at least the same number of values as supplied to it.
-than the number of supplied values, where an extra result is supplied
+Additional results can be supplied---before the values that correspond
-before the others. The additional result, if any, must be a procedure
+to the supplied values---in the following pattern:
+
+@itemlist[
+
+ @item{An optional procedure, @racket[_result-wrapper-proc], which
+       will be applied to the results of @racket[proc]; followed by}
+
+ @item{any number of repetitions of @racket['mark _key _val] (i.e.,
+       three values), where the call @racket[_proc] is wrapped to
+       install a @tech{continuation mark} @racket[_key] and @racket[_val].}
+
+]
+
+If @racket[_result-wrapper-proc] is produced, it must be a procedure
 that accepts as many results as produced by @racket[proc]; it must
-return the same number of results.  If @racket[wrapper-proc] returns
+return the same number of results. If @racket[_result-wrapper-proc] is
-the same number of values as it is given (i.e., it does not return a
+not supplied, then @racket[proc] is called in @tech{tail position}
-procedure to impersonator @racket[proc]'s result), then @racket[proc] is
+with respect to the call to the impersonator.
-called in @tech{tail position} with respect to the call to the impersonator.
 
 For applications that include keyword arguments, @racket[wrapper-proc]
-must return an additional value before any other values but after the
+must return an additional value before any other values but after
-result-impersonating procedure (if any). The additional value must be a
+@racket[_result-wrapper-proc] and @racket['mark _key _val]
+sequences (if any). The additional value must be a
 list of replacements for the keyword arguments that were supplied to the
 impersonator (i.e., not counting optional arguments that were
 not supplied). The arguments must be ordered according to the sorted
@@ -221,13 +234,59 @@ If any @racket[prop] is @racket[impersonator-prop:application-mark] and if the
 associated @racket[prop-val] is a pair, then the call to @racket[proc]
 is wrapped with @racket[with-continuation-mark] using @racket[(car
 prop-val)] as the mark key and @racket[(cdr prop-val)] as the mark
-value. In addition, if @racket[continuation-mark-set-first] with
+value. In addition, if the immediate
-@racket[(car prop-val)] produces a value for the immediate
+continuation frame of the call to the impersonated procedure
-continuation frame of the call to the impersonated procedure, the value is
+includes a value for @racket[(car prop-val)]---that is, if
+@racket[call-with-immediate-continuation-mark] would produce a value
+for @racket[(car prop-val)] in the call's continuation---then the value is
 also installed as an immediate value for @racket[(car prop-val)] as a
 mark during the call to @racket[wrapper-proc] (which allows tail-calls
 of impersonators with respect to wrapping impersonators to be detected within
-@racket[wrapper-proc]).}
+@racket[wrapper-proc]).
+
+@history[#:changed "6.3.0.5" @elem{Added support for @racket['mark
+                                   _key _val] results from
+                                   @racket[wrapper-proc].}]
+
+ @examples[
+
+ (define (add15 x) (+ x 15))
+ (define add15+print
+   (impersonate-procedure add15
+                          (λ (x)
+                            (printf "called with ~s\n" x)
+                            (values (λ (res)
+                                      (printf "returned ~s\n" res)
+                                      res)
+                                    x))))
+ (add15 27)
+ (add15+print 27)
+           
+ (define-values (imp-prop:p1 imp-prop:p1? imp-prop:p1-get)
+   (make-impersonator-property 'imp-prop:p1))
+ (define-values (imp-prop:p2 imp-prop:p2? imp-prop:p2-get)
+   (make-impersonator-property 'imp-prop:p2))
+  
+ (define add15.2 (impersonate-procedure add15 #f imp-prop:p1 11))
+ (add15.2 2)
+ (imp-prop:p1? add15.2)
+ (imp-prop:p1-get add15.2)
+ (imp-prop:p2? add15.2)
+ 
+ (define add15.3 (impersonate-procedure add15.2 #f imp-prop:p2 13))
+ (add15.3 3)
+ (imp-prop:p1? add15.3)
+ (imp-prop:p1-get add15.3)
+ (imp-prop:p2? add15.3)
+ (imp-prop:p2-get add15.3)
+ 
+ (define add15.4 (impersonate-procedure add15.3 #f imp-prop:p1 101))
+ (add15.4 4)
+ (imp-prop:p1? add15.4)
+ (imp-prop:p1-get add15.4)
+ (imp-prop:p2? add15.4)
+ (imp-prop:p2-get add15.4)]
+}
 
 @defproc[(impersonate-procedure* [proc procedure?]
                                  [wrapper-proc (or/c procedure? #f)]
@@ -387,6 +446,7 @@ or override impersonator-property values of @racket[box].}
                            [remove-proc (hash? any/c . -> . any/c)]
                            [key-proc (hash? any/c . -> . any/c)]
                            [clear-proc (or/c #f (hash? . -> . any)) #f]
+                           [equal-key-proc (or/c #f (hash? any/c . -> . any/c)) #f]
                            [prop impersonator-property?]
                            [prop-val any] ... ...)
           (and/c hash? impersonator?)]{
@@ -402,7 +462,7 @@ In addition, operations like
 @racket[hash-iterate-key] or @racket[hash-map], which extract
 keys from the table, use @racket[key-proc] to filter keys extracted
 from the table. Operations like @racket[hash-iterate-value] or
-@racket[hash-iterate-map] implicitly use @racket[hash-ref] and
+@racket[hash-values] implicitly use @racket[hash-ref] and
 therefore redirect through @racket[ref-proc].
 
 The @racket[ref-proc] must accept @racket[hash] and a key passed
@@ -440,6 +500,19 @@ If @racket[clear-proc] is @racket[#f], then @racket[hash-clear] or
 @racket[hash-clear!] on the impersonator is implemented using
 @racket[hash-iterate-key] and @racket[hash-remove] or @racket[hash-remove!].
 
+If @racket[equal-key-proc] is not @racket[#f], it effectively
+interposes on calls to @racket[equal?], @racket[equal-hash-code], and
+@racket[equal-secondary-hash-code] for the keys of @racket[hash]. The
+@racket[equal-key-proc] must accept as its arguments @racket[hash] and
+a key that is either mapped by @racket[hash] or passed to
+@racket[hash-ref], etc., where the latter has potentially been
+adjusted by the corresponding @racket[ref-proc], etc@|.__| The result
+is a value that is passed to @racket[equal?],
+@racket[equal-hash-code], and @racket[equal-secondary-hash-code] as
+needed to hash and compare keys. In the case of @racket[hash-set!] or
+@racket[hash-set], the key that is passed to @racket[equal-key-proc]
+is the one stored in the hash table for future lookup.
+
 The @racket[hash-iterate-value], @racket[hash-map], or
 @racket[hash-for-each] functions use a combination of
 @racket[hash-iterate-key] and @racket[hash-ref]. If a key
@@ -448,7 +521,10 @@ produced by @racket[key-proc] does not yield a value through
 
 Pairs of @racket[prop] and @racket[prop-val] (the number of arguments
 to @racket[impersonate-hash] must be odd) add impersonator properties
-or override impersonator-property values of @racket[hash].}
+or override impersonator-property values of @racket[hash].
+
+@history[#:changed "6.3.0.11" @elem{Added the @racket[equal-key-proc]
+                                    argument.}]}
 
 
 @defproc[(impersonate-channel [channel channel?]
@@ -707,7 +783,6 @@ or structure type.
          #:changed "6.1.1.8" @elem{Added optional @racket[struct-type]
                                    argument.}]}
 
-
 @defproc[(chaperone-vector [vec vector?]
                            [ref-proc (vector? exact-nonnegative-integer? any/c . -> . any/c)]
                            [set-proc (vector? exact-nonnegative-integer? any/c . -> . any/c)]
@@ -743,6 +818,7 @@ the same value or a chaperone of the value that it is given.  The
                          [remove-proc (hash? any/c . -> . any/c)]
                          [key-proc (hash? any/c . -> . any/c)]
                          [clear-proc (or/c #f (hash? . -> . any)) #f]
+                         [equal-key-proc (or/c #f (hash? any/c . -> . any/c)) #f]
                          [prop impersonator-property?]
                          [prop-val any] ... ...)
           (and/c hash? chaperone?)]{
@@ -752,8 +828,12 @@ and support for immutable hashes. The @racket[ref-proc] procedure must
 return a found value or a chaperone of the value. The
 @racket[set-proc] procedure must produce two values: the key that it
 is given or a chaperone of the key and the value that it is given or a
-chaperone of the value. The @racket[remove-proc] and @racket[key-proc]
+chaperone of the value. The @racket[remove-proc], @racket[key-proc],
-procedures must produce the given key or a chaperone of the key.}
+and @racket[equal-key-proc]
+procedures must produce the given key or a chaperone of the key.
+
+@history[#:changed "6.3.0.11" @elem{Added the @racket[equal-key-proc]
+                                    argument.}]}
 
 @defproc[(chaperone-struct-type [struct-type struct-type?]
                                 [struct-info-proc procedure?]
@@ -865,11 +945,12 @@ procedure.
      (lambda (n) (* n 2))
      (lambda (n) (+ n 1))))
 
+  (eval:error
    (call-with-continuation-prompt
      (lambda ()
        (abort-current-continuation bad-chaperone 5))
      bad-chaperone
-    (lambda (n) n))
+     (lambda (n) n)))
 
   (define good-chaperone
     (chaperone-prompt-tag
@@ -907,10 +988,11 @@ given.
      (lambda (l) (map char-upcase l))
      string->list))
 
+  (eval:error
    (with-continuation-mark bad-chaperone "timballo"
      (continuation-mark-set-first
       (current-continuation-marks)
-     bad-chaperone))
+      bad-chaperone)))
 
   (define (checker s)
     (if (> (string-length s) 5)

pkgs/racket-doc/scribblings/reference/class.scrbl

@@ -71,11 +71,10 @@
 
 )
 
-@(interaction-eval #:eval class-eval (require racket/class racket/contract))
+@examples[#:hidden #:eval class-eval
-@(interaction-eval
+          (require racket/class racket/contract)]
-  #:eval class-ctc-eval
+@examples[#:hidden #:eval class-ctc-eval
-  (require racket/class racket/contract))
+          (require racket/class racket/contract)]
-
 
 @title[#:tag "mzlib:class" #:style 'toc]{Classes and Objects}
 
@@ -196,8 +195,9 @@ is the most specific requirement from its superinterfaces. If the
 superinterfaces specify inconsistent derivation requirements, the
 @exnraise[exn:fail:object].
 
-@defexamples[
+@examples[
 #:eval class-ctc-eval
+#:no-prompt
 (define file-interface<%>
   (interface () open close read-byte write-byte))
 (define directory-interface<%>
@@ -226,8 +226,9 @@ extended to produce the internal structure type for instances of the
 class (so that no information about fields is accessible to the
 structure type property's guard, if any).
 
-@defexamples[
+@examples[
 #:eval class-eval
+#:no-prompt
 (define i<%> (interface* () ([prop:custom-write
                               (lambda (obj port mode) (void))])
                method1 method2 method3))
@@ -387,8 +388,9 @@ calling subclass augmentations of methods (see
 
 Like @racket[class*], but omits the @racket[_interface-expr]s, for the case that none are needed.
 
-@defexamples[
+@examples[
 #:eval class-eval
+#:no-prompt
 (define book-class%
   (class object%
     (field (pages 5))
@@ -404,15 +406,16 @@ to the current object (i.e., the object being initialized or whose
 method was called). Use outside the body of a @racket[class*] form is
 a syntax error.
 
-@defexamples[
+@examples[
 #:eval class-eval
-(define (describe obj)
+(eval:no-prompt
+ (define (describe obj)
    (printf "Hello ~a\n" obj))
-(define table%
+ (define table%
    (class object%
      (define/public (describe-self)
        (describe this))
-    (super-new)))
+     (super-new))))
 (send (new table%) describe-self)
 ]}
 
@@ -423,21 +426,22 @@ of the current object (i.e., the object being initialized or whose
 method was called).  Use outside the body of a @racket[class*] form is
 a syntax error.
 
-@defexamples[
+@examples[
 #:eval class-eval
-(define account%
+(eval:no-prompt
+ (define account%
    (class object% 
      (super-new)
      (init-field balance)
      (define/public (add n)
        (new this% [balance (+ n balance)]))))
-(define savings%
+ (define savings%
    (class account%
      (super-new)
      (inherit-field balance)
      (define interest 0.04)
      (define/public (add-interest)
-      (send this add (* interest balance)))))
+       (send this add (* interest balance))))))
 (let* ([acct (new savings% [balance 500])]
        [acct (send acct add 500)]
        [acct (send acct add-interest)])
@@ -447,7 +451,7 @@ a syntax error.
 @defclassforms[
   [(inspect inspector-expr) ()]
   [(init init-decl ...) ("clinitvars")
-   @defexamples[#:eval class-eval
+   @examples[#:eval class-eval
      (class object%
        (super-new)
        (init turnip
@@ -455,7 +459,7 @@ a syntax error.
              [carrot 'good]
              [(internal-rutabaga rutabaga) 'okay]))]]
   [(init-field init-decl ...) ("clinitvars" "clfields")
-   @defexamples[#:eval class-eval
+   @examples[#:eval class-eval
      (class object%
        (super-new)
        (init-field turkey
@@ -463,87 +467,97 @@ a syntax error.
                    [chicken 7]
                    [(internal-emu emu) 13]))]]
   [(field field-decl ...) ("clfields")
-   @defexamples[#:eval class-eval
+   @examples[#:eval class-eval
      (class object%
        (super-new)
        (field [minestrone 'ready]
               [(internal-coq-au-vin coq-au-vin) 'stewing]))]]
   [(inherit-field maybe-renamed ...) ("clfields")
-   @defexamples[#:eval class-eval
+   @examples[#:eval class-eval
+     (eval:no-prompt
       (define cookbook%
         (class object%
           (super-new)
           (field [recipes '(caldo-verde oyakodon eggs-benedict)]
-                [pages 389])))
+                 [pages 389]))))
      (class cookbook%
        (super-new)
        (inherit-field recipes
                       [internal-pages pages]))]]
   [* ((init-rest id) (init-rest)) ("clinitvars")
-   @defexamples[#:eval class-eval
+   @examples[#:eval class-eval
+     (eval:no-prompt
       (define fruit-basket%
         (class object%
           (super-new)
           (init-rest fruits)
-         (displayln fruits)))
+          (displayln fruits))))
      (make-object fruit-basket% 'kiwi 'lychee 'melon)]]
   [(public maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define jumper%
          (class object%
            (super-new)
            (define (skip) 'skip)
            (define (hop) 'hop)
-          (public skip [hop jump])))
+           (public skip [hop jump]))))
       (send (new jumper%) skip)
       (send (new jumper%) jump)]]
   [(pubment maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define runner%
          (class object%
            (super-new)
            (define (run) 'run)
            (define (trot) 'trot)
-          (pubment run [trot jog])))
+           (pubment run [trot jog]))))
       (send (new runner%) run)
       (send (new runner%) jog)]]
   [(public-final maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define point%
          (class object%
            (super-new)
            (init-field [x 0] [y 0])
             (define (get-x) x)
            (define (do-get-y) y)
-          (public-final get-x [do-get-y get-y])))
+           (public-final get-x [do-get-y get-y]))))
       (send (new point% [x 1] [y 3]) get-y)
+      (eval:error
        (class point%
          (super-new)
          (define (get-x) 3.14)
-        (override get-x))]]
+         (override get-x)))]]
   [(override maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define sheep%
          (class object%
            (super-new)
            (define/public (bleat)
-            (displayln "baaaaaaaaah"))))
+             (displayln "baaaaaaaaah")))))
+      (eval:no-prompt
        (define confused-sheep%
          (class sheep%
            (super-new)
            (define (bleat)
              (super bleat)
              (displayln "???"))
-          (override bleat)))
+           (override bleat))))
       (send (new sheep%) bleat)
       (send (new confused-sheep%) bleat)]]
   [(overment maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define turkey%
          (class object%
            (super-new)
            (define/public (gobble)
-            (displayln "gobble gobble"))))
+             (displayln "gobble gobble")))))
+      (eval:no-prompt
        (define extra-turkey%
          (class turkey%
            (super-new)
@@ -551,50 +565,56 @@ a syntax error.
              (super gobble)
              (displayln "gobble gobble gobble")
              (inner (void) gobble))
-          (overment gobble)))
+           (overment gobble))))
+      (eval:no-prompt
        (define cyborg-turkey%
          (class extra-turkey%
            (super-new)
            (define/augment (gobble)
-            (displayln "110011111011111100010110001011011001100101"))))
+             (displayln "110011111011111100010110001011011001100101")))))
       (send (new extra-turkey%) gobble)
       (send (new cyborg-turkey%) gobble)]]
   [(override-final maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define meeper%
          (class object%
            (super-new)
            (define/public (meep)
-            (displayln "meep"))))
+             (displayln "meep")))))
+      (eval:no-prompt
        (define final-meeper%
          (class meeper%
            (super-new)
            (define (meep)
              (super meep)
              (displayln "This meeping ends with me"))
-          (override-final meep)))
+           (override-final meep))))
       (send (new meeper%) meep)
       (send (new final-meeper%) meep)]]
   [(augment maybe-renamed ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define buzzer%
          (class object%
            (super-new)
            (define/pubment (buzz)
              (displayln "bzzzt")
-            (inner (void) buzz))))
+             (inner (void) buzz)))))
+      (eval:no-prompt
        (define loud-buzzer%
          (class buzzer%
            (super-new)
            (define (buzz)
              (displayln "BZZZZZZZZZT"))
-          (augment buzz)))
+           (augment buzz))))
       (send (new buzzer%) buzz)
       (send (new loud-buzzer%) buzz)]]
   [(augride maybe-renamed ...) ("clmethoddefs")]
   [(augment-final maybe-renamed ...) ("clmethoddefs")]
   [(private id ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define light%
          (class object%
            (super-new)
@@ -602,42 +622,47 @@ a syntax error.
            (define (toggle) (set! on? (not on?)))
            (private toggle)
            (define (flick) (toggle))
-          (public flick)))
+           (public flick))))
-      (send (new light%) toggle)
+      (eval:error (send (new light%) toggle))
       (send (new light%) flick)]]
   [(abstract id ...) ("clmethoddefs")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define train%
          (class object%
            (super-new)
            (abstract get-speed)
            (init-field [position 0])
            (define/public (move)
-            (new this% [position (+ position (get-speed))]))))
+             (new this% [position (+ position (get-speed))])))))
+      (eval:no-prompt
        (define acela%
          (class train%
            (super-new)
-          (define/override (get-speed) 241)))
+           (define/override (get-speed) 241))))
+      (eval:no-prompt
        (define talgo-350%
          (class train%
            (super-new)
-          (define/override (get-speed) 330)))
+           (define/override (get-speed) 330))))
-      (new train%)
+      (eval:error (new train%))
       (send (new acela%) move)]]
   [(inherit maybe-renamed ...) ("classinherit")
-    @defexamples[#:eval class-eval
+    @examples[#:eval class-eval
+      (eval:no-prompt
        (define alarm%
          (class object%
            (super-new)
            (define/public (alarm)
-            (displayln "beeeeeeeep"))))
+             (displayln "beeeeeeeep")))))
+      (eval:no-prompt
        (define car-alarm%
          (class alarm%
            (super-new)
            (init-field proximity)
            (inherit alarm)
            (when (< proximity 10)
-            (alarm))))
+             (alarm)))))
       (new car-alarm% [proximity 5])]]
   [(inherit/super maybe-renamed ...)  ("classinherit")]
   [(inherit/inner maybe-renamed ...) ("classinherit")]
@@ -1067,9 +1092,10 @@ hidden name (except as a top-level definition). The
 @racket[interface->method-names] procedure does not expose hidden
 names.
 
-@defexamples[
+@examples[
 #:eval class-eval
-(define-values (r o)
+(eval:no-prompt
+ (define-values (r o)
    (let ()
      (define-local-member-name m)
      (define c% (class object%
@@ -1078,10 +1104,10 @@ names.
      (define o (new c%))
     
      (values (send o m)
-            o)))
+             o))))
 
 r
-(send o m)
+(eval:error (send o m))
 ]}
 
 
@@ -1121,28 +1147,27 @@ Produces an integer hash code consistent with
 @racket[member-name-key=?]  comparisons, analogous to
 @racket[equal-hash-code].}
 
-@defexamples[
+@examples[
 #:eval class-eval
-(define (make-c% key)
+(eval:no-prompt
+ (define (make-c% key)
    (define-member-name m key)
    (class object% 
      (define/public (m) 10)
-    (super-new)))
+     (super-new))))
 
 (send (new (make-c% (member-name-key m))) m)
-(send (new (make-c% (member-name-key p))) m)
+(eval:error (send (new (make-c% (member-name-key p))) m))
 (send (new (make-c% (member-name-key p))) p)
-]
 
-@defs+int[
+(eval:no-prompt
-#:eval class-eval
+ (define (fresh-c%)
-[(define (fresh-c%)
    (let ([key (generate-member-key)])
      (values (make-c% key) key)))
 
- (define-values (fc% key) (fresh-c%))]
+ (define-values (fc% key) (fresh-c%)))
 
-(send (new fc%) m)
+(eval:error (send (new fc%) m))
 (let ()
   (define-member-name p key)
   (send (new fc%) p))
@@ -1352,15 +1377,16 @@ the last method call, which is expected to be an object. Each
 
 This is the functional analogue of @racket[send*].
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
-(define point%
+(eval:no-prompt
+ (define point%
    (class object%
      (super-new)
      (init-field [x 0] [y 0])
      (define/public (move-x dx)
        (new this% [x (+ x dx)]))
      (define/public (move-y dy)
-      (new this% [y (+ y dy)]))))
+       (new this% [y (+ y dy)])))))
 
 (send+ (new point%)
        (move-x 5)
@@ -1802,8 +1828,8 @@ The external contracts are as follows:
    If only the field name is present, this is equivalent to insisting only
    that the method is present in the class.
    
-   @defexamples[#:eval 
+   @examples[#:eval class-eval
-                class-eval
+                (eval:no-prompt
                  (define woody%
                    (class object%
                      (define/public (draw who)
@@ -1812,11 +1838,11 @@ The external contracts are as follows:
                 
                  (define/contract woody+c%
                    (class/c [draw (->m symbol? string?)])
-                  woody%)
+                   woody%))
                 
                 (send (new woody%) draw #f)
                 (send (new woody+c%) draw 'zurg)
-                (send (new woody+c%) draw #f)]
+                (eval:error (send (new woody+c%) draw #f))]
    }
  @item{An external field contract, tagged with @racket[field], describes the
    behavior of the value contained in that field when accessed from outside
@@ -1827,8 +1853,8 @@ The external contracts are as follows:
    If only the field name is present, this is equivalent to using the 
    contract @racket[any/c] (but it is checked more efficiently).
    
-   @defexamples[#:eval
+   @examples[#:eval class-eval
-                class-eval
+                (eval:no-prompt
                  (define woody/hat%
                    (class woody%
                      (field [hat-location 'uninitialized])
@@ -1840,15 +1866,16 @@ The external contracts are as follows:
                             [lose-hat (->m void?)]
                             [find-hat (->m void?)]
                             (field [hat-location (or/c 'on-head 'lost)]))
-                  woody/hat%)
+                   woody/hat%))
                 
                 (get-field hat-location (new woody/hat%))
                 (let ([woody (new woody/hat+c%)])
                   (send woody lose-hat)
                   (get-field hat-location woody))
-                (get-field hat-location (new woody/hat+c%))
+                (eval:error (get-field hat-location (new woody/hat+c%)))
+                (eval:error
                  (let ([woody (new woody/hat+c%)])
-                  (set-field! hat-location woody 'under-the-dresser))]
+                   (set-field! hat-location woody 'under-the-dresser)))]
    
    }
  @item{An initialization argument contract, tagged with @racket[init],
@@ -1861,8 +1888,8 @@ The external contracts are as follows:
    If only the initialization argument name is present, this is equivalent to using the 
    contract @racket[any/c] (but it is checked more efficiently).
    
-   @defexamples[#:eval
+   @examples[#:eval class-eval
-                class-eval
+                (eval:no-prompt
                  (define woody/init-hat%
                    (class woody%
                      (init init-hat-location)
@@ -1876,13 +1903,14 @@ The external contracts are as follows:
                             [find-hat (->m void?)]
                             (init [init-hat-location (or/c 'on-head 'lost)])
                             (field [hat-location (or/c 'on-head 'lost)]))
-                  woody/init-hat%)
+                   woody/init-hat%))
                 (get-field hat-location
                            (new woody/init-hat+c%
                                 [init-hat-location 'lost]))
+                (eval:error
                  (get-field hat-location
                             (new woody/init-hat+c%
-                                [init-hat-location 'slinkys-mouth]))]
+                                 [init-hat-location 'slinkys-mouth])))]
    
    }
  @item{The contracts listed in an @racket[init-field] section are
@@ -1906,18 +1934,19 @@ As with the external contracts, when a method or field name is specified
    contracted class's method implementation is no longer the entry point
    for dynamic dispatch.
    
-   @defexamples[#:eval
+   @examples[#:eval class-eval
-                class-eval
                 (new (class woody+c%
                        (inherit draw)
                        (super-new)
                        (printf "woody sez: “~a”\n" (draw "evil dr porkchop"))))
+                (eval:no-prompt
                  (define/contract woody+c-inherit%
                    (class/c (inherit [draw (->m symbol? string?)]))
-                  woody+c%)
+                   woody+c%))
+                (eval:error
                  (new (class woody+c-inherit%
                         (inherit draw)
-                       (printf "woody sez: ~a\n" (draw "evil dr porkchop"))))]
+                        (printf "woody sez: ~a\n" (draw "evil dr porkchop")))))]
    
    }
   @item{A method contract tagged with @racket[super] describes the behavior of
@@ -1932,8 +1961,8 @@ As with the external contracts, when a method or field name is specified
    contract the controls how the @racket[super] methods must
    be invoked.
    
-   @defexamples[#:eval
+   @examples[#:eval class-eval
-                class-eval
+                (eval:no-prompt
                  (define/contract woody2+c%
                    (class/c (super [draw (->m symbol? string?)]))
                    (class woody%
@@ -1943,7 +1972,7 @@ As with the external contracts, when a method or field name is specified
                          [(a b) (string-append (super draw a)
                                                " and "
                                                (super draw b))]))
-                    (super-new)))
+                     (super-new))))
                 (send (new woody2+c%) draw 'evil-dr-porkchop  'zurg)
                 (send (new woody2+c%) draw "evil dr porkchop" "zurg")]
    
@@ -1971,8 +2000,8 @@ As with the external contracts, when a method or field name is specified
    add a contract to make sure that overriding @racket[draw]
    doesn't break @racket[draw2].   
    
-   @defexamples[#:eval
+   @examples[#:eval class-eval
-                class-eval
+                (eval:no-prompt
                  (define/contract woody2+override/c%
                    (class/c (override [draw (->m symbol? string?)]))
                    (class woody+c%
@@ -1987,11 +2016,12 @@ As with the external contracts, when a method or field name is specified
                    (class woody2+override/c%
                      (define/override (draw x)
                        'not-a-string)
-                    (super-new)))
+                     (super-new))))
 
+                (eval:error
                  (send (new woody2+broken-draw) draw2 
                        'evil-dr-porkchop
-                      'zurg)]
+                       'zurg))]
    
    
    }
@@ -2390,7 +2420,7 @@ A @racket[print] request is directed to @racket[custom-write].}
 
 Returns @racket[#t] if @racket[v] is an object, @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (object? (new object%))
   (object? object%)
   (object? "clam chowder")
@@ -2401,7 +2431,7 @@ Returns @racket[#t] if @racket[v] is an object, @racket[#f] otherwise.
 
 Returns @racket[#t] if @racket[v] is a class, @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (class? object%)
   (class? (class object% (super-new)))
   (class? (new object%))
@@ -2413,7 +2443,7 @@ Returns @racket[#t] if @racket[v] is a class, @racket[#f] otherwise.
 
 Returns @racket[#t] if @racket[v] is an interface, @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (interface? (interface () empty cons first rest))
   (interface? object%)
   (interface? "gazpacho")
@@ -2424,7 +2454,7 @@ Returns @racket[#t] if @racket[v] is an interface, @racket[#f] otherwise.
 
 Returns @racket[#t] if @racket[v] is a @tech{generic}, @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define c%
     (class object%
       (super-new)
@@ -2448,7 +2478,7 @@ This procedure is similar in spirit to
 @racket[eq?] but also works properly with contracts
 (and has a stronger guarantee).
 
-@defexamples[#:eval class-ctc-eval
+@examples[#:eval class-ctc-eval
   (define obj-1 (new object%))
   (define obj-2 (new object%))
   (define/contract obj-3 (object/c) obj-1)
@@ -2468,7 +2498,7 @@ This procedure is similar in spirit to
 Like @racket[object=?], but accepts @racket[#f] for either argument and
 returns @racket[#t] if both arguments are @racket[#f].
 
-@defexamples[#:eval class-ctc-eval
+@examples[#:eval class-ctc-eval
    (object-or-false=? #f (new object%))
    (object-or-false=? (new object%) #f)
    (object-or-false=? #f #f)
@@ -2482,7 +2512,7 @@ returns @racket[#t] if both arguments are @racket[#f].
 Returns a vector representing @racket[object] that shows its
 inspectable fields, analogous to @racket[struct->vector].
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (object->vector (new object%))
   (object->vector (new (class object%
                          (super-new)
@@ -2494,7 +2524,7 @@ inspectable fields, analogous to @racket[struct->vector].
 
 Returns the interface implicitly defined by @racket[class].
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (class->interface object%)
 ]}
 
@@ -2504,7 +2534,7 @@ Returns the interface implicitly defined by @racket[class].
 Returns the interface implicitly defined by the class of
 @racket[object].
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (object-interface (new object%))
 ]}
 
@@ -2515,7 +2545,7 @@ Returns @racket[#t] if @racket[v] is an instance of a class
 @racket[type] or a class that implements an interface @racket[type],
 @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define point<%> (interface () get-x get-y))
   (define 2d-point%
     (class* object% (point<%>)
@@ -2536,7 +2566,7 @@ Returns @racket[#t] if @racket[v] is an instance of a class
 Returns @racket[#t] if @racket[v] is a class derived from (or equal
 to) @racket[cls], @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (subclass? (class object% (super-new)) object%)
   (subclass? object% (class object% (super-new)))
   (subclass? object% object%)
@@ -2548,7 +2578,7 @@ to) @racket[cls], @racket[#f] otherwise.
 Returns @racket[#t] if @racket[v] is a class that implements
 @racket[intf], @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define i<%> (interface () go))
   (define c%
     (class* object% (i<%>)
@@ -2565,7 +2595,7 @@ Returns @racket[#t] if @racket[v] is a class that implements
 Returns @racket[#t] if @racket[v] is an interface that extends
 @racket[intf], @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define point<%> (interface () get-x get-y))
   (define colored-point<%> (interface (point<%>) color))
 
@@ -2581,7 +2611,7 @@ Returns @racket[#t] if @racket[intf] (or any of its ancestor
 interfaces) includes a member with the name @racket[sym], @racket[#f]
 otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define i<%> (interface () get-x get-y))
   (method-in-interface? 'get-x i<%>)
   (method-in-interface? 'get-z i<%>)
@@ -2595,7 +2625,7 @@ including methods inherited from superinterfaces, but not including
 methods whose names are local (i.e., declared with
 @racket[define-local-member-name]).
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (define i<%> (interface () get-x get-y))
   (interface->method-names i<%>)
 ]}
@@ -2607,7 +2637,7 @@ methods whose names are local (i.e., declared with
 Returns @racket[#t] if @racket[object] has a method named @racket[sym]
 that accepts @racket[cnt] arguments, @racket[#f] otherwise.
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
 (define c%
   (class object%
     (super-new)
@@ -2628,7 +2658,7 @@ Returns a list of all of the names of the fields bound in
 not including fields whose names are local (i.e., declared with
 @racket[define-local-member-name]).
 
-@defexamples[#:eval class-eval
+@examples[#:eval class-eval
   (field-names (new object%))
   (field-names (new (class object% (super-new) (field [x 0] [y 0]))))
 ]}
@@ -2701,6 +2731,47 @@ a method that is not supplied by an object.
 
 }
 
+@defproc[(class-seal [class class?]
+                     [key symbol?]
+                     [unsealed-inits (listof symbol?)]
+                     [unsealed-fields (listof symbol?)]
+                     [unsealed-methods (listof symbol?)]
+                     [inst-proc (-> class? any)]
+                     [member-proc (-> class? (listof symbol?) any)])
+         class?]{
+
+Adds a seal to a given class keyed with the symbol @racket[key]. The
+given @racket[unsealed-inits], @racket[unsealed-fields], and
+@racket[unsealed-methods] list corresponding class members that are
+unaffected by sealing.
+
+When a class has any seals, the @racket[inst-proc] procedure is called
+on instantiation (normally, this is used to raise an error on
+instantiation) and the @racket[member-proc] function is called
+(again, this is normally used to raise an error) when a subclass
+attempts to add class members that are not listed in the unsealed lists.
+
+The @racket[inst-proc] is called with the class value on which an
+instantiation was attempted. The @racket[member-proc] is called with
+the class value and the list of initialization argument, field, or
+method names.
+}
+
+@defproc[(class-unseal [class class?]
+                       [key symbol?]
+                       [wrong-key-proc (-> class? any)])
+         class?]{
+
+Removes a seal on a class that has been previously sealed with the
+@racket[class-seal] function and the given @racket[key].
+
+If the unseal removed all of the seals in the class, the class
+value can be instantiated or subclassed freely. If the given
+class value does not contain or any seals or does not contain
+any seals with the given key, the @racket[wrong-key-proc] function
+is called with the class value.
+}
+
 @; ----------------------------------------------------------------------
 
 @include-section["surrogate.scrbl"]

pkgs/racket-doc/scribblings/reference/cmdline.scrbl

@@ -1,5 +1,7 @@
 #lang scribble/doc
-@(require "mz.rkt" (for-label racket/cmdline))
+@(require "mz.rkt"
+          (for-label racket/cmdline)
+          (only-in scribble/core element))
 
 @title{Command-Line Parsing}
 
@@ -104,7 +106,7 @@ A normal flag specification has four parts:
  @racketvalfont{"-}@racketvarfont{x}@racketvalfont{"} or
  @racketvalfont{"+}@racketvarfont{x}@racketvalfont{"} for some
  character @racketvarfont{x}, or
- @racketvalfont{"--}@racketvarfont{x}@racketvalfont{"} or
+ @racketvalfont[@element[#f]{"--}]@racketvarfont{x}@racketvalfont{"} or
  @racketvalfont{"++}@racketvarfont{x}@racketvalfont{"} for some
  sequence of characters @racketvarfont{x}. An @racketvarfont{x} cannot
  contain only digits or digits plus a single decimal point, since

pkgs/racket-doc/scribblings/reference/collects.scrbl

@@ -1,6 +1,7 @@
 #lang scribble/doc
 @(require "mz.rkt"
-          (for-label setup/dirs))
+          (for-label setup/dirs
+                     setup/collection-search))
 
 @title[#:tag "collects"]{Libraries and Collections}
 
@@ -264,6 +265,9 @@ collection specified by the @racket[collection]s, where the second
 search uses the values of @racket[current-library-collection-links]
 and @racket[current-library-collection-paths].
 
+@margin-note{See also @racket[collection-search] in
+             @racketmodname[setup/collection-search].}
+
 If @racket[file] is not found, but @racket[file] ends in
 @filepath{.rkt} and a file with the suffix @filepath{.ss} exists, then
 the directory of the @filepath{.ss} file is used. If @racket[file] is