diff --git a/collects/scribblings/reference/printer.scrbl b/collects/scribblings/reference/printer.scrbl index fbec44a3fd..97f89c5083 100644 --- a/collects/scribblings/reference/printer.scrbl +++ b/collects/scribblings/reference/printer.scrbl @@ -13,14 +13,14 @@ render the character/byte content directly to the output port. When the @scheme[print-graph] parameter is set to @scheme[#t], then the printer first scans an object to detect cycles. The scan traverses -the components of pairs, vectors, boxes (when @scheme[print-box] is -@scheme[#t]), hash tables (when @scheme[print-hash-table] is -@scheme[#t]), and fields of structures exposed by -@scheme[struct->vector] (when @scheme[print-struct] is +the components of pairs, mutable pairs, vectors, boxes (when +@scheme[print-box] is @scheme[#t]), hash tables (when +@scheme[print-hash-table] is @scheme[#t]), and fields of structures +exposed by @scheme[struct->vector] (when @scheme[print-struct] is @scheme[#t]). If @scheme[print-graph] is @scheme[#t], then this information is used to display sharing by printing graph definitions -and references (see @secref["parse-graph"]). If a cycle is detected -in the initial scan, then @scheme[print-graph] is effectively set to +and references (see @secref["parse-graph"]). If a cycle is detected in +the initial scan, then @scheme[print-graph] is effectively set to @scheme[#t] automatically. With the exception of displaying byte strings, printing is defined in diff --git a/collects/scribblings/reference/stx-ops.scrbl b/collects/scribblings/reference/stx-ops.scrbl index 91339410b4..df92e58946 100644 --- a/collects/scribblings/reference/stx-ops.scrbl +++ b/collects/scribblings/reference/stx-ops.scrbl @@ -10,7 +10,7 @@ otherwise. See also @secref["stxobj-model"].} @defproc[(syntax-source [stx syntax?]) any]{ -Returns the source for the syntax object @scheme[stx], or @scheme[#f] +Returns the source for the @tech{syntax object} @scheme[stx], or @scheme[#f] if none is known. The source is represented by an arbitrary value (e.g., one passed to @scheme[read-syntax]), but it is typically a file path string. Source-location information is dropped for a syntax @@ -23,23 +23,23 @@ object that is marshaled as part of compiled code; see also false/c)]{ Returns the line number (positive exact integer) for the start of the -syntax object in its source, or @scheme[#f] if the line number or +@tech{syntax object} in its source, or @scheme[#f] if the line number or source is unknown. The result is @scheme[#f] if and only if @scheme[(syntax-column stx)] produces @scheme[#f]. See also @secref["linecol"], and see @scheme[syntax-source] for information -about marshaling compiled syntax objects.} +about marshaling compiled @tech{syntax object}s.} @defproc[(syntax-column [stx syntax?]) - (or/c nonnegative-exact-integer? + (or/c exact-nonnegative-integer? false/c)]{ Returns the column number (non-negative exact integer) for the start -of the syntax object in its source, or @scheme[#f] if the source +of the @tech{syntax object} in its source, or @scheme[#f] if the source column is unknown. The result is @scheme[#f] if and only if @scheme[(syntax-line stx)] produces @scheme[#f]. See also @secref["linecol"], and see @scheme[syntax-source] for information -about marshaling compiled syntax objects.} +about marshaling compiled @tech{syntax object}s.} @defproc[(syntax-position [stx syntax?]) @@ -47,33 +47,33 @@ about marshaling compiled syntax objects.} false/c)]{ Returns the character position (positive exact integer) for the start -of the syntax object in its source, or @scheme[#f] if the source +of the @tech{syntax object} in its source, or @scheme[#f] if the source position is unknown. See also @secref["linecol"], and see @scheme[syntax-source] for information about marshaling compiled -syntax objects.} +@tech{syntax object}s.} @defproc[(syntax-span [stx syntax?]) - (or/c nonnegative-exact-integer? + (or/c exact-nonnegative-integer? false/c)]{ Returns the span (non-negative exact integer) in characters of the -syntax object in its source, or @scheme[#f] if the span is +@tech{syntax object} in its source, or @scheme[#f] if the span is unknown. See also @scheme[syntax-source] for information about -marshaling compiled syntax objects.} +marshaling compiled @tech{syntax object}s.} @defproc[(syntax-original? [stx syntax?]) boolean?]{ Returns @scheme[#t] if @scheme[stx] has the property that @scheme[read-syntax] and @scheme[read-honu-syntax] attach to the -syntax objects that they generate (see @secref["stxprops"]), and if +@tech{syntax object}s that they generate (see @secref["stxprops"]), and if @scheme[stx]'s @tech{lexical information} does not indicate that the object was introduced by a syntax transformer (see @secref["stxobj-model"]). The result is @scheme[#f] otherwise. This -predicate can be used to distinguish syntax objects in an expanded +predicate can be used to distinguish @tech{syntax object}s in an expanded expression that were directly present in the original expression, as -opposed to syntax objects inserted by macros.} +opposed to @tech{syntax object}s inserted by macros.} @defproc[(syntax-source-module [stx syntax?]) @@ -86,7 +86,7 @@ for the module whose source contains @scheme[stx], or @scheme[#f] if @defproc[(syntax-e [stx syntax?]) any]{ -Unwraps the immediate datum structure from a syntax object, +Unwraps the immediate datum structure from a @tech{syntax object}, leaving nested syntax structure (if any) in place. The result of @scheme[(syntax-e @scheme[stx])] is one of the following: @@ -98,64 +98,81 @@ leaving nested syntax structure (if any) in place. The result of @item{the empty list} - @item{a vector containing syntax objects} + @item{an immutable vector containing @tech{syntax object}s} + + @item{an immutable box containing @tech{syntax object}s} @item{some other kind of datum---usually a number, boolean, or string} } -A @deftech{syntax pair} is a pair containing a syntax object as its +A @deftech{syntax pair} is a pair containing a @tech{syntax object} as its first element, and either the empty list, a syntax pair, or a syntax object as its second element. -A syntax object that is the result of @scheme[read-syntax] reflects +A @tech{syntax object} that is the result of @scheme[read-syntax] reflects the use of delimited @litchar{.} in the input by creating a syntax object for every pair of parentheses in the source, and by creating a -pair-valued syntax object @italic{only} for parentheses in the +pair-valued @tech{syntax object} @italic{only} for parentheses in the source. See @secref["parse-pair"] for more information.} @defproc[(syntax->list [stx syntax?]) (or/c list? false/c)]{ -Returns an immutable list of syntax objects or @scheme[#f]. The result -is a list of syntax objects when @scheme[(syntax->datum stx)] -would produce a list. In other words, @tech{syntax pairs} in -@scheme[(syntax-e @scheme[stx])] are flattened.} +Returns a list of @tech{syntax object}s or @scheme[#f]. The result is a list +of @tech{syntax object}s when @scheme[(syntax->datum stx)] would produce a +list. In other words, @tech{syntax pairs} in @scheme[(syntax-e stx)] +are flattened.} -@defproc[(syntax->datum ...) any]{ +@defproc[(syntax->datum [stx syntax?]) any]{ -Returns a datum by stripping the lexical and source-location -information from @scheme[stx]. Graph structure is preserved by the -conversion.} +Returns a datum by stripping the lexical information, source-location +information, properties, and certificates from @scheme[stx]. Inside of +pairs, (immutable) vectors, and (immutable) boxes, @tech{syntax object}s are +recursively stripped. + +The stripping operation does not mutate @scheme[stx]; it creates new +pairs, vectors, and boxes as needed to strip lexical and +source-location information recursively.} @defproc[(datum->syntax [ctxt (or/c syntax? false/c)] [v any/c] [srcloc (or/c syntax? false/c (list/c any/c - (or/c positive-exact-integer? false/c) - (or/c nonnegative-exact-integer? false/c) - (or/c nonnegative-exact-integer? false/c) - (or/c positive-exact-integer? false/c)))] + (or/c exact-positive-integer? false/c) + (or/c exact-nonnegative-integer? false/c) + (or/c exact-nonnegative-integer? false/c) + (or/c exact-positive-integer? false/c)))] [prop (or/c syntax? false/c) #f] [cert (or/c syntax? false/c) #f]) syntax?]{ -Converts the @tech{datum} @scheme[v] to a @tech{syntax object}, using -syntax objects already in @scheme[v] in the result. Converted objects -in @scheme[v] are given the lexical context information of -@scheme[ctxt] and the source-location information of -@scheme[srcloc]. If @scheme[v] is not already a syntax object, then -the resulting immediate syntax object it is given the properties (see -@secref["stxprops"]) of @scheme[prop] and the @tech{inactive certificates} -(see @secref["stxcerts"]) of @scheme[cert]. Any of -@scheme[ctxt], @scheme[srcloc], @scheme[prop], or @scheme[cert] can be -@scheme[#f], in which case the resulting syntax has no lexical +Converts the @tech{datum} @scheme[v] to a @tech{syntax object}. If +@scheme[v] is a pair, vector, or box, then the contents are +recursively converted; mutable vectors and boxes are essentially +replaced by immutable vectors and boxes. @tech{Syntax object}s already in +@scheme[v] are preserved as-is in the result. For any kind of value +other than a pair, vector, box, or @tech{syntax object}, conversion means +wrapping the value with lexical information, source-location +information, properties, and certificates. + +Converted objects in @scheme[v] are given the lexical context +information of @scheme[ctxt] and the source-location information of +@scheme[srcloc]. If @scheme[v] is not already a @tech{syntax object}, then +the resulting immediate @tech{syntax object} is given the properties (see +@secref["stxprops"]) of @scheme[prop] and the @tech{inactive +certificates} (see @secref["stxcerts"]) of @scheme[cert]; if +@scheme[v] is a pair, vector, or box, recursively converted values are +not given properties or certificates. + +Any of @scheme[ctxt], @scheme[srcloc], @scheme[prop], or @scheme[cert] +can be @scheme[#f], in which case the resulting syntax has no lexical context, source information, new properties, and/or certificates. If @scheme[srcloc] is not @scheme[#f] -or a syntax object, it must be a list of five elements: +or a @tech{syntax object}, it must be a list of five elements: @schemeblock[ (list source-name line column position span) @@ -170,15 +187,14 @@ name; @scheme[line] is an integer for the source line, or @scheme[#f]; numbers or both be @scheme[#f], otherwise the @exnraise[exn:fail:contract]. -Graph structure is preserved by the conversion of @scheme[v] to a -syntax object, but graph structure that is distributed among distinct -syntax objects in @scheme[v] may be hidden from future applications of -@scheme[syntax->datum] and @scheme[syntax-graph?] to the new -syntax object.} +Graph structure is not preserved by the conversion of @scheme[v] to a +@tech{syntax object}. Instead, @scheme[v] is essentially unfolded into a +tree. If @scheme[v] has a cycle through pairs, vectors, and boxes, +then the @exnraise[exn:fail:contract].} @defproc[(identifier? [v any/c]) boolean?]{ -Returns @scheme[#t] if @scheme[v] is a syntax object and +Returns @scheme[#t] if @scheme[v] is a @tech{syntax object} and @scheme[(syntax-e stx)] produces a symbol.} diff --git a/collects/scribblings/scribble/reader.scrbl b/collects/scribblings/scribble/reader.scrbl index 2e2a8a4d75..6f0d9b5ec5 100644 --- a/collects/scribblings/scribble/reader.scrbl +++ b/collects/scribblings/scribble/reader.scrbl @@ -3,7 +3,9 @@ scribble/bnf scribble/eval "utils.ss" - (for-syntax scheme/base)) + (for-syntax scheme/base) + (for-label (only-in scribble/reader + use-at-readtable))) @(define read-eval (make-base-eval)) @interaction-eval[#:eval read-eval (require (for-syntax scheme/base))] @@ -30,7 +32,8 @@ A PLT Scheme manual more likely starts with which installs a reader, wraps the file content afterward into a MzScheme module, and parses the body into a document using -@filepath{decode.ss}. See @secref["docreader"] for more information. +@schememodname[scribble/decode]. See @secref["docreader"] for more +information. Another way to use the reader is to use the @scheme[use-at-readtable] function to switch the current readtable to a readtable that parses diff --git a/doc/release-notes/mzscheme/MzScheme_4.txt b/doc/release-notes/mzscheme/MzScheme_4.txt index c179a9c7ff..5a47f5eca9 100644 --- a/doc/release-notes/mzscheme/MzScheme_4.txt +++ b/doc/release-notes/mzscheme/MzScheme_4.txt @@ -4,10 +4,9 @@ in several significant ways: - The documentation has been re-organized and re-written. Instead of just reference manuals that occasionally provide examples, our - documentation is now based on "guides" that provides a friendly - overview and extensive examples, and then separate "references" - that provide the details (typically in a more terse, precise - style). + documentation is now based on a "guide" that provides a friendly + overview and examples, and then separate "references" that provide + the details (typically in a more terse, precise style). - Pairs created with `cons', `list', `map', etc. are immutable. A separate datatype, "mpair", implements mutable pairs, with the @@ -83,6 +82,9 @@ in several significant ways: used carefully; library functions should typically allow "~" to be a relative path). + - Literal vectors and boxes are immutable, as are vectors and boxes + produced by `syntax->datum'. + - Hash table printing is enabled by default, and vector-length printing is disabled by default. Opaque structure instances no longer print with a leading "struct:" between angle brackets, and @@ -91,7 +93,9 @@ in several significant ways: - Graph input syntax, such as `#0=(1 . #0#)' is no longer allowed in program syntax parsed by `read-syntax', though it is still allowed - for `read'. + for `read'. The `datum->syntax' function now raises an exception + when given a cyclic value, and non-cyclic graph structure (though + pairs, vectors, and boxes) is not preserved. - In fully expanded code, `#%datum' expands to `quote'. When using the `mzscheme' language, beware that `if' in expansions is the `if' @@ -115,10 +119,10 @@ in several significant ways: `prop:equal+hash' property allows customization of `equal?' for a structure type. - - The contract library (in `scheme/contract') no longer exports - object or mixin contracts. Instead they are exported from - `scheme/class'. (The libraries in "mzlib" remain the same as - before.) + - The contract library (in `scheme/contract') does not export object + or mixin contracts. Instead they are exported from + `scheme/class'. The libraries in the "mzlib" collection remain as + before. ====================================================================== Immutable and Mutable Pairs @@ -126,13 +130,14 @@ in several significant ways: Making pairs immutable helps prevent security and design holes that result form unexpected mutation of lists; Schemers do not usually -think about lists as mutable, and they wrote code that fails in exotic +think about lists as mutable, and they write code that fails in exotic ways if a list is mutated concurrently. For similar reasons, immutable lists work better with higher-order contracts. Although this change may sound drastic, our experience to date is that uses of mutable pairs are isolated and easy to convert to either -mpairs or functional style. +mpairs or functional style. The new `scheme/mpair' library provides +functions for processing mutable lists. For compatbility, the `cons' exported by the `r5rs' language module is an alias for `mcons', and the various list-consuming and -producing @@ -194,7 +199,7 @@ language module, instead of `mzscheme' or its close analogue Big" language: in addition to the core forms, it supplies contracts, the class system, the unit system, and the pretty printer. More precisely, the default module is `scheme/init', which is like -`scheme', but it installs the pretty printer. +`scheme', but installs the pretty printer and `help' form. The initial top-level environment is completely empty. Command-line flags like `-l' introduce bindings into the environment. Such bindings diff --git a/src/mzscheme/src/read.c b/src/mzscheme/src/read.c index 923770c5d6..73a9de268d 100644 --- a/src/mzscheme/src/read.c +++ b/src/mzscheme/src/read.c @@ -4456,6 +4456,7 @@ static Scheme_Object *read_compact(CPort *port, int use_stack) break; case CPT_BOX: v = scheme_box(read_compact(port, 0)); + SCHEME_SET_IMMUTABLE(v); break; case CPT_PAIR: if (need_car) { @@ -4497,6 +4498,10 @@ static Scheme_Object *read_compact(CPort *port, int use_stack) SCHEME_VEC_ELS(vec)[i] = cv; } + if (l) { + SCHEME_SET_IMMUTABLE(vec); + } + v = vec; } break; diff --git a/src/mzscheme/src/schvers.h b/src/mzscheme/src/schvers.h index 8cde526dd3..e79aa107a0 100644 --- a/src/mzscheme/src/schvers.h +++ b/src/mzscheme/src/schvers.h @@ -10,12 +10,12 @@ The string and the separate X/Y/Z/W numbers must be updated consistently. */ -#define MZSCHEME_VERSION "3.99.0.9" +#define MZSCHEME_VERSION "3.99.0.10" #define MZSCHEME_VERSION_X 3 #define MZSCHEME_VERSION_Y 99 #define MZSCHEME_VERSION_Z 0 -#define MZSCHEME_VERSION_W 9 +#define MZSCHEME_VERSION_W 10 #define MZSCHEME_VERSION_MAJOR ((MZSCHEME_VERSION_X * 100) + MZSCHEME_VERSION_Y) #define MZSCHEME_VERSION_MINOR ((MZSCHEME_VERSION_Z * 1000) + MZSCHEME_VERSION_W) diff --git a/src/mzscheme/src/stxobj.c b/src/mzscheme/src/stxobj.c index 3c70734776..69c6b10ac6 100644 --- a/src/mzscheme/src/stxobj.c +++ b/src/mzscheme/src/stxobj.c @@ -4575,6 +4575,7 @@ static Scheme_Object *syntax_to_datum_inner(Scheme_Object *o, } else if (SCHEME_BOXP(v)) { v = syntax_to_datum_inner(SCHEME_BOX_VAL(v), with_marks, mt); result = scheme_box(v); + SCHEME_SET_IMMUTABLE(result); } else if (SCHEME_VECTORP(v)) { int size = SCHEME_VEC_SIZE(v), i; Scheme_Object *r, *a; @@ -4585,8 +4586,10 @@ static Scheme_Object *syntax_to_datum_inner(Scheme_Object *o, a = syntax_to_datum_inner(SCHEME_VEC_ELS(v)[i], with_marks, mt); SCHEME_VEC_ELS(r)[i] = a; } - + result = r; + if (size) + SCHEME_SET_IMMUTABLE(result); } else result = v;