replace "traditional Racket" references with "Racket BC"

Makefile

@@ -246,7 +246,7 @@ native-for-cross:
 	cd racket/src/build/cross; $(MAKE) reconfigure MORE_CONFIGURE_ARGS="$(MORE_CROSS_CONFIGURE_ARGS)"
 	cd racket/src/build/cross/racket; $(MAKE)
 
-racket/src/build/cross/Makefile: racket/src/configure racket/src/cfg-racket racket/src/Makefile.in
+racket/src/build/cross/Makefile: racket/src/configure racket/src/cfg-bc racket/src/Makefile.in
 	cd racket/src/build/cross; ../../configure $(MORE_CROSS_CONFIGURE_ARGS)
 
 # ------------------------------------------------------------

build.md

@@ -229,25 +229,24 @@ below.
 
 The `make cs` target (or `make cs-as-is` for a rebuild, or `nmake
 win32-cs` on Windows with Visual Studio) builds a variant of Racket that
-runs on Chez Scheme. By default, the executables for the Racket-on-Chez
+runs on Chez Scheme. By default, the executables for the Racket CS
-variant all have a `cs` or `CS` suffix, and they coexist with a
+variant all have a `cs` or `CS` suffix, and they coexist with a Racket
-traditional Racket build by keeping compiled files in a machine-specific
+BC build by keeping compiled files in a machine-specific subdirectory of
-subdirectory of the `"compiled"` directory. You can remove the `cs`
+the `"compiled"` directory. You can remove the `cs` suffix and the
-suffix and the subdirectory in `"compiled"` by providing
+subdirectory in `"compiled"` by providing `RACKETCS_SUFFIX=""` to
-`RACKETCS_SUFFIX=""` to `make`. (One day, the default for
+`make`. (One day, the default for `RACKETCS_SUFFIX` will change from
-`RACKETCS_SUFFIX` will change from `"cs"` to `""`.)
+`"cs"` to `""`.)
 
-Building Racket on Chez Scheme requires either an existing Racket or pb
+Building Racket CS requires either an existing Racket or pb (portable
-(portable bytecode) boot files for Chez Scheme. By default, pb bootf
+bytecode) boot files for Chez Scheme. By default, pb boot files are
-iles are downloaded from a separate Git repository by `make cs`. If you
+downloaded from a separate Git repository by `make cs`. If you have
-have Racket v7.1 or later, then you can choose instead to bootstrap
+Racket v7.1 or later, then you can choose instead to bootstrap using
-using that Racket implementation with
+that Racket implementation with
 
   `make cs RACKET=racket`
 
-Use `make both` to build both traditional Racket and Racket on Chez
+Use `make both` to build both Racket BC and Racket CS, where packages
-Scheme, where packages are updated and documentation is built only once
+are updated and documentation is built only once (using Racket BC).
-(using traditional Racket).
 
 ### 1.7. Even More Instructions: Building Racket Pieces
 

pkgs/racket-build-guide/build.scrbl

@@ -210,8 +210,8 @@ If you need even more control over the build, carry on to
 The @exec{make cs} target (or @exec{make cs-as-is} for a rebuild, or
 @exec{nmake win32-cs} on Windows with Visual Studio) builds a variant
 of Racket that runs on Chez Scheme. By default, the executables for
-the Racket-on-Chez variant all have a @litchar{cs} or @litchar{CS}
+the Racket CS variant all have a @litchar{cs} or @litchar{CS}
-suffix, and they coexist with a traditional Racket build by keeping
+suffix, and they coexist with a Racket BC build by keeping
 compiled files in a machine-specific subdirectory of the
 @filepath{compiled} directory. You can remove the @litchar{cs} suffix
 and the subdirectory in @filepath{compiled} by providing
@@ -219,17 +219,17 @@ and the subdirectory in @filepath{compiled} by providing
 the default for @exec{RACKETCS_SUFFIX} will change from @tt{"cs"} to
 @tt{""}.)
 
-Building Racket on Chez Scheme requires either an existing Racket or
+Building Racket CS requires either an existing Racket or pb (portable
-pb (portable bytecode) boot files for Chez Scheme. By default, pb
+bytecode) boot files for Chez Scheme. By default, pb boot files are
-bootf iles are downloaded from a separate Git repository by @exec{make
+downloaded from a separate Git repository by @exec{make cs}. If you
-cs}. If you have Racket v7.1 or later, then you can choose instead
+have Racket v7.1 or later, then you can choose instead to bootstrap
-to bootstrap using that Racket implementation with
+using that Racket implementation with
 
 @commandline{make cs RACKET=racket}
 
-Use @exec{make both} to build both traditional Racket and Racket on
+Use @exec{make both} to build both Racket BC and Racket CS, where
-Chez Scheme, where packages are updated and documentation is built only
+packages are updated and documentation is built only once (using
-once (using traditional Racket).
+Racket BC).
 
 
 @; ------------------------------------------------------------

racket/src/LICENSE.txt

@@ -2,13 +2,14 @@ Racket is distributed under the MIT license and the Apache version 2.0
 license, at your option. However, the Racket runtime system includes
 components distributed under other licenses. In short:
 
-  * The traditional Racket runtime system includes code distributed
+  * The Racket CS runtime system embeds Chez Scheme, which is
-    under the GNU Lesser General Public License, version 3. This
+    distributed under the Apache version 2.0 license. This runtime
-    runtime system is built from code in racket/src/racket.
+    system is built from code in racket/src/cs and
+    racket/src/ChezScheme.
 
-  * The Racket on Chez Scheme runtime system embeds Chez Scheme, which
+  * The Racket BC runtime system includes code distributed under the
-    is distributed under the Apache version 2.0 license. This runtime
+    GNU Lesser General Public License, version 3. This runtime system
-    system is built from code in racket/src/cs.
+    is built from code in racket/src/racket.
 
 Except for Windows executables that are created with the "embed DLLs"
 option, the runtime system remains separate as a shared library or
@@ -38,7 +39,7 @@ The following are used in all Racket executables:
   rktio/rktio_sha2.c. mbed TLS is licensed under the Apache
   v2.0 License.
 
-The following are used only in the traditional Racket executable:
+The following are used only in the Racket BC executable:
 
 * libscheme. Code from libscheme can be found in
   racket. See the file LICENSE-libscheme.txt

racket/src/README.txt

@@ -26,66 +26,48 @@ Report bugs:
 
 
 ========================================================================
- Traditional Racket versus Racket-on-Chez
+ Racket BC (ByteCode / Before Chez) versus Racket CS (Chez Scheme)
 ========================================================================
 
 This source directory contains implementations for two different
-versions of Racket: the traditional implementation that is
+versions of Racket: the original BC implementation that is
-substantially implemented in C, and an implementation that builds on
+substantially implemented in C, and the CS implementation that builds
-Chez Scheme.
+on Chez Scheme.
 
-Traditional Racket
+Racket BC
-------------------
+---------
 
-By default, `configure` and the Windows scripts build the traditional
+By default, `configure` and the Windows scripts build the BC
 implementation of Racket.
 
-If you need more information specific to the traditional
+To build Racket BC on Windows, see See "worksp\README.txt" for
-implementation of Racket, see "racket/README.txt".
-
-Racket on Chez Scheme
----------------------
-
-To build Racket-on-Chez on Unix variants or Mac OS:
-
- * ... in addition to the traditional variant of Racket: supply
-   `--enable-cs` or `--enable-csdefault` to `configure`.
-
-   The generated Racket-on-Chez executables will have a "cs" suffix
-   for `--enable-cs`, and it will not have a "cs" suffix for
-   `--enable-csdefault`. Also, plain `make` will still build the
-   traditional Racket implementation with `--enable-cs`; use `make cs`
-   to build and `make install-cs` to install. With
-   `--enable-csdefault`, plain `make` and `make install` will build
-   and install Racket-on-Chez.
-
- * ... by itself: supply `--enable-csonly` to `configure`.
- 
-   The generated Racket-on-Chez executables will *not* have a "cs"
-   suffix. Unlike `--enable-csdefault`, you must specify an existing
-   Racket using `--enable-racket=...`.
-
-Chez Scheme is included in a Racket source distribution and
-`configure` detects that source, so no separate download or Git
-checkout is needed in that case.
-
-Chez Scheme is not included in the Racket Git repository. Building
-Racket-on-Chez from a Git checkout requires a "ChezScheme" build
-checkout within the build directory or at at an alternate location
-specified by the `--enable-scheme=...` argument to `configure`.
-
-Use the patched version of Chez Scheme at
-
-    https://github.com/racket/ChezScheme
-
-We hope to eventually return to the current development version from
-
-    https://github.com/cisco/ChezScheme
-
-To build Racket-on-Chez on Windows, see See "worksp\README.txt" for
 information.
 
-If you need more information specific to Racket-on-Chez, see
+If you need more information specific to Racket BC, see
+"racket/README.txt".
+
+Racket CS
+---------
+
+To build Racket CS on Unix variants or Mac OS:
+
+ * ... in addition Racket BC: supply `--enable-cs` to `configure`.
+
+   The generated Racket CS executables will have a "cs" suffix. Also,
+   plain `make` will still build Racket BC with `--enable-cs`; use
+   `make cs` to build and `make install-cs` to install.
+
+ * ... by itself: supply `--enable-csdefault` to `configure`.
+ 
+   The generated Racket CS executables will *not* have a "cs" suffix.
+
+Chez Scheme is included in Racket source distributions and the source
+repository.
+
+To build Racket CS on Windows, see See "worksp\README.txt" for
+information.
+
+If you need more information specific to Racket CS, see
 "cs/README.txt".
 
 
@@ -113,11 +95,11 @@ Quick instructions:
  you don't anticipate updating/rebuilding, but it will be harder to
  restart from scratch should you need to.
 
- Some build modes may require GNU `make`. For example, when building
+ Some build modes may require GNU Make. For example, when building the
- the traditional Racket implementation, the content of the "foreign"
+ Racket CS implementation, GNU Make is required. When building the
- subdirectory requires GNU `make` if no installed "libffi" is
+ Racket BC implementation, the content of the "foreign" subdirectory
- detected. If the build fails with another variant of `make`, please
+ requires GNU Make if no installed "libffi" is detected. If the build
- try using GNU `make`.
+ fails with another variant of `make`, please try using GNU Make.
 
 Detailed instructions:
 
@@ -358,9 +340,8 @@ Cross-compilation requires at least two flags to `configure`:
 
  * `--enable-racket=RACKET`, where RACKET is a path to a Racket
    executable that runs on the build platform; the executable must be
-   the same version of Racket and the same virtual machine (i.e.,
+   the same version of Racket and the same virtual machine (i.e., CS
-   traditional Racket or Racket on Chez Scheme) as being built for the
+   or BC) as being built for the target platform.
-   target platform.
 
    This flag is needed because building and installing Racket requires
    running (an existing build of) Racket.
@@ -377,7 +358,7 @@ For Racket-on-Chez, an additional flag is needed:
    current platform, and a cross-compiled Chez Scheme will be created
    in the same directory.
 
-Some less commonly needed `configure` flags for traditional Racket:
+Some less commonly needed `configure` flags for Racket BC:
 
  * `--enable-stackup`, if the target platform`s stack grows up.
 
@@ -393,8 +374,8 @@ Some less commonly needed `configure` flags for traditional Racket:
  Cross-compiling for Android
 ========================================================================
 
-[Currently, cross-compilation for Android works only for the
+[Currently, cross-compilation for Android works only for the Racket BC
- traditional Racket implementation.]
+ implementation.]
 
 As an example of cross-compiling, to compile for Android on ARM using
 the NDK, use (all on one line)
@@ -416,7 +397,7 @@ the [comp] of your choice and the [platform] used to compile.
  Cross-compiling for iOS
 ========================================================================
 
-[Currently, cross-compilation works only for the traditional Racket
+[Currently, cross-compilation works only for the Racket BC
  implementation.]
 
 To compile the Racket runtime system as a Framework for iOS, use (all
@@ -459,16 +440,16 @@ of the `racket` executable (and variants), while "../collects"
 contains the additional Racket libraries that are included in a
 minimal Racket distribution.
 
-Sources for the traditional Racket implementation
+Sources for the Racket BC implementation
 -------------------------------------------------
 
- * "racket" --- traditional `racket` executable
+ * "racket" --- `racket` BC executable
 
    This implementation can build from "scratch" with a C compiler, but
    first by building a CGC variant of Racket to transform the C
    sourses to build a (normal) 3m variant.
 
- * "gracket" --- traditional `gracket` executable
+ * "gracket" --- `gracket` executable
 
  * "foreign" --- FFI implementation for "racket"
 
@@ -482,13 +463,10 @@ Sources for the traditional Racket implementation
 See also the shared sources below, which includes rktio and the macro
 expander.
 
-Sources for the Racket-on-Chez implementation
+Sources for the Racket CS implementation
----------------------------------------------
+----------------------------------------
 
- * "cs" --- Racket-on-Chez `racket` executable
+ * "cs" --- `racket` CS executable
-
-   Building requires both an existing Racket (possibly created from
-   the "racket" sources) and an existing Chez Scheme build.
 
  * "thread" --- thread scheduler
 
@@ -508,13 +486,14 @@ Sources shared by both Racket implementations
 
    This expander is both included in Racket executables and used to
    expand itself for inclusion in executables. It's also used to
-   expand other libraries for inclusion in Racket-on-Chez executables.
+   expand other libraries for inclusion in Racket CS executables, but
+   already-expanded versions are included with source in
+   "cs/schemified".
 
    If you change the expander, run `make` in its directory to generate
    the "startup.inc" file that holds the expander's implementation for
-   the traditional Racket variant. The Racket-on-Chez build (which
+   Racket BC. Also, run `make` in "cs" to rebuild expanded libraries
-   needs an existing Racket to build, anyway) picks up changes to
+   for Racket CS.
-   "expander" automatically.
 
  * "rktio" --- portability layer for low-level I/O
 
@@ -524,20 +503,19 @@ Sources shared by both Racket implementations
 
  * "schemify" --- a Racket-to-Scheme compiler, used by "cs" and "cify"
 
-        Similar to "expander", this layer is applied to itself and
+   Similar to "expander", this layer is applied to itself and other
-        other libraries for inclusion in "cs".
+   libraries for inclusion in "cs". If you change it, be sure to run
-
+   `make` in "cs".
 
  * "cify" --- a Racket-to-C compiler
 
-   This compiler is used only when embedding the expander as C code,
+   This compiler is used only when embedding the expander as C code in
-   instead of Racket bytecode, which is the default for platforms
+   Racket BC, instead of Racket bytecode, which is the default for
-   where the traditional Racket JIT is not supported.
+   platforms where the Racket BC JIT is not supported.
 
  * "start" --- main-executable wrapper
 
-   Startup wrappers used by both the tradition and Racket-on-CS
+   Startup wrappers used by both the Racket CS and BC implementations.
-   implementations. 
 
  * "worksp" --- Windows projects and build scripts
 
@@ -564,4 +542,3 @@ More shared utilities
  * "lt" --- `libtool` and `configure` support
 
  * "utils" --- miscellaneous
-

racket/src/ac/make-configure

@@ -2,7 +2,7 @@
 #|
 cd "`dirname \"$0\"`"
 src="../racket/configure.ac"
-tgt="../cfg-racket"
+tgt="../cfg-bc"
 if [ ! -e "$src" ]; then echo "abort: did not find $src"; exit 1; fi
 echo "Creating $tgt from $src"
 autoconf "$src" | racket "$0" > "$tgt"

racket/src/configure

@@ -1,10 +1,9 @@
 #! /bin/sh
 
-# Using `--enable-csdefault` or `--enable-csonly` avoids running `cfg-racket`
+# Using `--enable-csdefault` or `--enable-csonly` avoids running
-# and only uses `cfg-cs` and `cs/c/configure`.
+# `cfg-racket` and only uses `cfg-cs` and `cs/c/configure`.
 
-# Using `--enable-cs` or `--enable-csdefault` uses
+# Using `--enable-cs` uses both `cfg-racket` and `cs/c/configure`.
-# both `cfg-racket` and `cs/c/configure`.
 
 set -e
 

racket/src/cs/README.txt

@@ -1,4 +1,4 @@
-<The implementation of Racket on Chez Scheme (Racket CS) in this
+The implementation of Racket on Chez Scheme (Racket CS) in this
 directory is organized into two layers:
 
  * The immediate directory contains Scheme sources to implement Racket
@@ -154,8 +154,7 @@ Racket CS currently supports three compilation modes:
    the implementation into a pure interpreter.
 
  * Interpreter mode --- The compiled form of a module is a "bytecode"
-   tree (not unlike the traditional Racket's bytecode) that is
+   tree (not unlike Racket BC's bytecode) that is interpreted.
-   interpreted.
 
    Select this mode by setting the `PLT_CS_INTERP` environment
    variable. Alternatively, set `PLT_LINKLET_COMPILE_QUICK` when
@@ -355,8 +354,8 @@ compatibility.
 FFI Differences
 ---------------
 
-Compared to the traditional Racket implementation, Racket CS's FFI
+Compared to the Racket BC implementation, Racket CS's FFI behaves in
-behaves in several different ways:
+several different ways:
 
  * The `make-sized-byte-string` function always raises an exception,
    because a foreign address cannot be turned into a byte string whose
@@ -371,7 +370,7 @@ behaves in several different ways:
 
  * A `_gcpointer` can only refer to the start of an allocated object,
    and never the interior of an 'atomic-interior allocation. Like
-   traditional Racket, `_gcpointer` is equivalent to `_pointer` for
+   Racket BC, `_gcpointer` is equivalent to `_pointer` for
    sending values to a foreign procedure, return values from a
    callback that is called from foreign code, or for `ptr-set!`. For
    the other direction (receiving a foreign result, `ptr-ref`, and

racket/src/racket/README.txt

@@ -1,13 +1,13 @@
-This directory contains most of the source code to the traditional
+This directory contains most of the source code to the Racket BC
-implementation of Racket. See "../README.txt" for general information
+implementation. See "../README.txt" for general information on
-on building.
+building.
 
 
 ========================================================================
  CGC versus 3m
 ========================================================================
 
-Traditional Racket and GRacket have two variants: CGC and 3m. The CGC
+Racket BC and GRacket BC have two variants: CGC and 3m. The CGC
 variant is older, and it cooperates more easily with extensions
 written in C. The 3m variant is the default: it is more robust and
 usually provides better overall performance.

racket/src/start/README.txt

@@ -1,7 +1,6 @@
 This directory constraint source programs and fragments for wrapper
 executables used to start/embed Racket. The programs and fragments are
-used both for the traditional Racket virtual machine and Racket on
+used both for the Racket CS and BC implementations.
-Chez Scheme.
 
 ========================================================================
  Embedded Paths in the Executables

racket/src/worksp/README.txt

@@ -2,7 +2,7 @@ This directory contains scripts, solution files, and project files for
 building Racket using Visual Studio. Some parts or variants can be
 built using projects, but most use Visual Studio command-line tools.
 
-The traditional Racket implementation also compiles with MinGW; see
+The Racket BC implementation also compiles with MinGW; see
 "...\README.txt".
 
 
@@ -26,13 +26,12 @@ When using PowerShell, run the "msvcprep.ps1" script instead of
 work, but will not actually change any environment variables.
 
 After you have Visual Studio command-line tools set up, then you can
-build either the traditional Racket implementation or Racket-on-Chez
+build either the Racket BC or Racket CS implementations (or both).
-(or both).
 
-Traditional Racket
+Racket BC
-------------------
+---------
 
-Build the traditional Racket implementation using
+Build the Racket BC implementation using
 
    build.bat
 
@@ -44,32 +43,29 @@ the process of building "..\..\Racket.exe".
 
 See also "Completing the Build" below.
 
-Racket-on-Chez
+Racket CS
---------------
+---------
 
-Build the Racket-on-Chez implementation using
+Build the Racket CS implementation using
 
    build-cs.bat
 
-which builds "..\..\Racket3m.exe" to bootstrap the build.
+which builds "..\..\Racket3m.exe" to bootstrap the build, because the
+main build script is implemented in Racket.
 
-To instead build using an existing Racket installation, use
+To instead build using an existing Racket installation (version 7.1 or
+later), use
 
    racket.exe csbuild.rkt --racketcs-suffix ""
 
 The result is "..\..\Racket.exe", DLLs and "GRacket.exe" in
 "..\..\lib", and other files in "..\..\lib", "..\..\etc", etc.
-
+Many intermediate files will be put in "../build".
-Many intermediate files will be put in "../build", including a Chez
-Scheme checkout if it's not already present there; if a "ChezScheme"
-directory exists in the Racket source directory, it is copied to the
-build directory, otherwise it is cloned from a Git repository (in
-which case `git` must be available).
 
 See also "Completing the Build" below.
 
-Both Traditional Racket and Racket-on-Chez
+Both Racket BC and Racket CS
-------------------------------------------
+----------------------------
 
 When using "csbuild.rkt" directly, omit the `--racketcs-suffix ""`
 arguments to create "..\..\RacketCS.exe" executable instead of
@@ -78,8 +74,8 @@ read and bytecode in a subdirectory of "compiled" as described in
 "..\cs\README.txt".
 
 A "CS" suffix and using a subdirectory of "compiled" means that a
-Racket-on-Chez build as "RacketCS.exe" can coexist with a
+Racket CS build as "RacketCS.exe" can coexist with a BC build as
-traditional build as "Racket.exe". So, the sequence
+"Racket.exe". So, the sequence
 
    build.bat
    ..\..\Racket.exe csbuild.rkt
@@ -111,11 +107,10 @@ Only if you are starting completely from scratch, see also
  Building via Visual Studio Projects/Solutions
 ========================================================================
 
-Traditional Racket implementation's CGC variant can be built and
+The Racket BC implementation's CGC variant can be built and debugged
-debugged using visual Studio solutions and project. (See
+using visual Studio solutions and project. (See "..\racket\README.txt"
-"..\racket\README.txt" for information on traditional Racket
+for information on Racket BC variants.) Further steps using the
-variants.) Further steps using the command line can then build the 3m
+command line can then build the 3m variant and related executables.
-variant and related executables.
 
 The CGC implementation is split into several projects that are grouped
 into a few solutions. To build the `X' solution with Visual Studio,
@@ -274,8 +269,8 @@ See also "..\start\README.txt" for information on the embedded
  Embedding
 ========================================================================
 
-The traditional Racket implementation's DLLs can be used within an
+The Racket BC implementation's DLLs can be used within an embedding
-embedding application.
+application.
 
 The libraries