An @note was aligned with the line following it. With this change, the note is shifted up by about the size of a line.

Used by the DrRacket docs, and was broken when making the table extensible.

scribble-doc/scribblings/scribble/base.scrbl

@@ -605,7 +605,7 @@ Inserts a reference to the section tagged @racket[tag].
 
 If @racket[#:doc module-path] is provided, the @racket[tag] refers to
 a tag with a prefix determined by @racket[module-path]. When
-@exec{setup-plt} renders documentation, it automatically adds a tag
+@exec{raco setup} renders documentation, it automatically adds a tag
 prefix to the document based on the source module. Thus, for example,
 to refer to a section of the Racket reference,
 @racket[module-path] would be @racket['(lib

scribble-doc/scribblings/scribble/config.scrbl

@@ -172,7 +172,7 @@ configurable in the former way, since a document class determines a
 set of page-layout and font properties that are used by other
 commands. The style-replacement kind of configuration corresponds to
 re-defining Latex macros or overriding CSS class attributes.  When
-@exec{setup-plt} builds PDF documentation, it uses both kinds of
+@exec{raco setup} builds PDF documentation, it uses both kinds of
 configuration to produce a standard layout for Racket manuals;
 that is, it selects a particular page layout, and it replaces some
 @racketmodname[racket/base] styles.

scribble-doc/scribblings/scribble/core.scrbl

@@ -463,7 +463,7 @@ The recognized @tech{style properties} are as follows:
         be set separately for parts that start different HTML pages,
         otherwise it is effectively inherited by sub-parts; the
         default is @racket["scribble-racket-lang.org"], but
-        @exec{setup-plt} installs @racket["doc-racket-lang.org"] as the
+        @exec{raco setup} installs @racket["doc-racket-lang.org"] as the
         @tt{id} for any document that it builds.}
 
  @item{@racket[attributes] structure --- Provides additional HTML
@@ -1772,7 +1772,7 @@ The @racket[path] field can be a result of
 Used as a @tech{style property} on the main @racket[part] of a document
 to set a default prefix file, style file, and extra files (see
 @secref["config-style"]).  The defaults are used by the
-@exec{scribble} command-line tool for and @DFlag{latex} or @DFlag{pdf}
+@exec{scribble} command-line tool for @DFlag{latex} or @DFlag{pdf}
 mode if none are supplied via @DFlag{prefix} and @DFlag{style} (where
 @racket[extra-files] are used only when @racket[prefix] is used). A
 byte-string value is used directly like file content, and a path can

scribble-doc/scribblings/scribble/jfp.scrbl

@@ -55,3 +55,19 @@ If different authors have different affiliations, use
 use @racket[affiliation-mark] before each different affiliation within
 a single @racket[affiliation], using @racket[(affiliation-sep)] to
 separate affiliations.}
+
+Examples:
+@codeblock|{
+#lang scribble/jfp
+
+@title{My First Love Story}
+
+@((author/short "Romeo M. and Juliet C.")
+  "ROMEO" (affiliation-mark "1")
+  " and "
+  "JULIET" (affiliation-mark "2")
+  @affiliation[
+    "House Montague" (affiliation-mark "1")
+    (affiliation-sep)
+    "House Capulet" (affiliation-mark "2")])
+}|

scribble-doc/scribblings/scribble/manual.scrbl

@@ -1949,6 +1949,28 @@ produced by @racket[content-expr] should normally start with a capital
 letter and end with a period, but it can be a sentence fragment such
 as ``Added a @racket[#:changed] form.''
 
+Examples:
+@codeblock[#:keep-lang-line? #f]|{
+#lang scribble/manual
+@defthing[tasty-burrito burrito?]{
+  Compatible with the API of a sandwich, but not legally a
+  sandwich in Massachusetts.
+
+  @history[#:added "1.0"
+           #:changed "1.1" "Refactored tortilla."
+           #:changed "1.2" @elem{Now includes @emph{guacamole}.}]
+}
+}|
+@doc-render-examples[
+  @defthing[tasty-burrito burrito?]{
+    Compatible with the API of a sandwich, but not legally a
+    sandwich in Massachusetts.
+
+    @history[#:added "1.0"
+             #:changed "1.1" "Refactored tortilla."
+             #:changed "1.2" @elem{Now includes @emph{guacamole}.}]
+}]
+
 @history[#:added "1.1"]}
 
 @; ------------------------------------------------------------------------
@@ -2049,6 +2071,16 @@ rendered document.}
 Indicates that the index entry corresponds to a module definition via
 @racket[defmodule] and company.}
 
+@deftogether[(
+@defstruct[(language-index-desc module-path-index-desc) ()]{}
+@defstruct[(reader-index-desc module-path-index-desc) ()]{}
+)]{
+Indicates that the index entry corresponds to a module definition via
+@racket[defmodule] with the @racket[#:lang] or @racket[#:reader] option.
+For example, a module definition via @racket[defmodulelang] has a
+@racket[language-index-desc] index entry and a module definition via
+@racket[defmodulereader] has a @racket[reader-index-desc] index entry.}
+
 @defstruct[exported-index-desc ([name symbol?]
                                [from-libs (listof module-path?)])]{
 

scribble-doc/scribblings/scribble/renderer.scrbl

@@ -396,6 +396,16 @@ are own their own pages. A value of @racket[0] is treated the same as
 
 Specializes a @racket[render<%>] class for generating Latex input.}}
 
+@defparam[extra-character-conversions convs (-> char? (or/c string? #f))]{
+Function that maps (special) characters to strings corresponding to the Latex
+code that should be used to render them. This function should return false for
+any character it does not know how to handle.
+
+Scribble already converts many special characters to the proper Latex
+commands. This parameter should be used in case you need characters it does not
+support yet.
+}
+
 @; ----------------------------------------
 
 @section{PDF Renderer}

scribble-lib/scribble/base-render.rkt

@@ -72,35 +72,41 @@
       #f)
 
     (define/public (format-number number sep [keep-separator? #f])
-      (if (or (null? number)
+      (cond
-              (andmap (lambda (x) (or (not x) (equal? x "")))
+       [(or (null? number)
-                      number)
+            (andmap (lambda (x) (or (not x) (equal? x "")))
-              (and (not (car number))
+                    number)
-                   (not (ormap number? number))))
+            (and (not (car number))
-          null
+                 (not (ormap number? number))))
-          (cons (let ([s (string-append
+        null]
-                          (apply
+       [else
-                           string-append
+        (define result-s
-                           (map (lambda (n) 
+          (let ([s (string-append
-                                  (cond
+                    (apply
-                                   [(number? n) (format "~a." n)]
+                     string-append
-                                   [(or (not n) (string? n)) ""]
+                     (map (lambda (n) 
-                                   [(pair? n) (string-append (car n) (cadr n))]))
+                            (cond
-                                (reverse (cdr number))))
+                             [(number? n) (format "~a." n)]
-                          (if (and (car number) 
+                             [(or (not n) (string? n)) ""]
-                                   (not (equal? "" (car number))))
+                             [(pair? n) (string-append (car n) (cadr n))]))
-                              (if (pair? (car number))
+                          (reverse (cdr number))))
-                                  (if keep-separator?
+                    (if (and (car number) 
-                                      (string-append (caar number)
+                             (not (equal? "" (car number))))
-                                                     (cadar number))
+                        (if (pair? (car number))
-                                      (caar number))
+                            (if keep-separator?
-                                  (format "~a." (car number)))
+                                (string-append (caar number)
-                              ""))])
+                                               (cadar number))
-                  (if (or keep-separator?
+                                (caar number))
-                          (pair? (car number)))
+                            (format "~a." (car number)))
-                      s
+                        ""))])
-                      (substring s 0 (sub1 (string-length s)))))
+            (if (or keep-separator?
-                sep)))
+                    (pair? (car number))
+                    (equal? s ""))
+                s
+                (substring s 0 (sub1 (string-length s))))))
+        (if (equal? result-s "")
+            null
+            (cons result-s sep))]))
 
     (define/public (number-depth number)
       (if (null? number)

scribble-lib/scribble/elsarticle/.gitignore

@@ -0,0 +1,2 @@
+# to avoid committing it by accident, since we can't distribute it
+/elsarticle.cls

scribble-lib/scribble/elsarticle/elsarticle.tex

@@ -0,0 +1,5 @@
+\newcommand{\ELSauthor}[1]{\author{#1}}
+\newcommand{\ELSaddress}[1]{\address{#1}}
+\newcommand{\ELSemail}[1]{\ead{#1}}
+
+\newcommand{\ELSabstract}[1]{\begin{abstract}#1\end{abstract}}

scribble-lib/scribble/elsarticle/lang.rkt

@@ -0,0 +1,68 @@
+#lang racket/base
+(require scribble/doclang
+         scribble/core
+         racket/file
+         (except-in scribble/base author)
+         (prefix-in s/b: scribble/base)
+         scribble/decode
+         "../private/defaults.rkt"
+         setup/collects
+         scribble/html-properties
+         scribble/latex-properties
+         scribble/latex-prefix
+         racket/stxparam
+         net/ftp
+         file/gunzip
+         (for-syntax racket/base
+                     racket/list
+                     racket/stxparam-exptime))
+
+(module test racket/base)
+
+(provide (except-out (all-from-out scribble/doclang) #%module-begin)
+         (all-from-out scribble/base)
+         (rename-out [module-begin #%module-begin])
+         frontmatter
+         abstract author email address)
+
+(define-syntax (module-begin stx)
+  ;; No options, currently, but keep in case we want to support some:
+  (syntax-case* stx () (lambda (a b) (eq? (syntax-e a) (syntax-e b)))
+    [(_ id ws . body)
+     ;; Skip intraline whitespace to find options:
+     (and (string? (syntax-e #'ws))
+          (regexp-match? #rx"^ *$" (syntax-e #'ws)))
+     #'(module-begin id . body)]
+    [(_ id . body)
+     #'(#%module-begin id (post-process) () . body)]))
+
+(define ((post-process) doc)
+  (add-defaults doc
+                (string->bytes/utf-8 (string-append "\\documentclass{elsarticle}\n"
+                                                    unicode-encoding-packages))
+                (scribble-file "elsarticle/style.tex")
+                '()
+                #f))
+
+(define elsarticle-extras
+  (let ([abs (lambda (s)
+               (path->collects-relative
+                (collection-file-path s "scribble" "elsarticle")))])
+    (list
+     (make-tex-addition (abs "elsarticle.tex")))))
+
+(define (LaTeX-element i)
+  (λ strs
+    (make-element (style i elsarticle-extras)
+                  ;; XXX maybe decode-content
+                  (decode-content strs))))
+
+(define abstract (LaTeX-element "ELSabstract"))
+(define author (LaTeX-element "ELSauthor"))
+(define address (LaTeX-element "ELSaddress"))
+(define email (LaTeX-element "ELSemail"))
+
+(define (frontmatter #:authors as
+                     #:abstract a)
+  (paragraph (style 'author '())
+             (append as (list a))))

scribble-lib/scribble/elsarticle/lang/reader.rkt

@@ -0,0 +1,3 @@
+#lang s-exp scribble/base/reader
+scribble/elsarticle/lang
+#:wrapper1 (lambda (t) (cons 'doc (t)))

scribble-lib/scribble/elsarticle/style.tex

@@ -0,0 +1,3 @@
+
+\renewcommand{\titleAndVersionAndAuthors}[3]{\begin{frontmatter}\title{#1}#3\end{frontmatter}}
+\renewcommand{\titleAndEmptyVersionAndAuthors}[3]{\titleAndVersionAndAuthors{#1}{#1}{#3}}

scribble-lib/scribble/eval.rkt

@@ -99,13 +99,15 @@
         [(eof-object? v)
          (let* ([line-accum (add-string string-accum line-accum)]
                 [flow-accum (add-line line-accum flow-accum)])
-           (list
+           (if (null? flow-accum)
-            (list.flow.list
+               null
-             (if (= 1 (length flow-accum))
+               (list
-               (car flow-accum)
+                (list.flow.list
-               (make-table
+                 (if (= 1 (length flow-accum))
-                #f
+                     (car flow-accum)
-                (map list.flow.list (reverse flow-accum)))))))]
+                     (make-table
+                      #f
+                      (map list.flow.list (reverse flow-accum))))))))]
         [(equal? #\newline v)
          (loop #f #f (add-line (add-string string-accum line-accum)
                                flow-accum))]

scribble-lib/scribble/latex-render.rkt

@@ -11,7 +11,8 @@
          setup/collects
          file/convertible)
 (provide render-mixin
-         make-render-part-mixin)
+         make-render-part-mixin
+         extra-character-conversions)
 
 (define current-table-mode (make-parameter #f))
 (define rendering-tt (make-parameter #f))
@@ -47,6 +48,8 @@
 (define-runtime-path skull-tex "scribble-skull.tex")
 (define skull-style (make-style #f (list (tex-addition skull-tex))))
 
+(define extra-character-conversions (make-parameter (λ (c) #f)))
+
 (define (render-mixin % #:image-mode [image-mode #f])
   (class %
     (super-new)
@@ -941,7 +944,8 @@
           [else ses])))
 
     (define/private (display-protected s)
-      (define rtt (rendering-tt))
+      (define rtt   (rendering-tt))
+      (define convs (extra-character-conversions))
       (cond
        [(eq? rtt 'exact)
         (display s)]
@@ -995,242 +999,244 @@
                      [(#\uDF) "{\\ss}"]
                      [else
                       (if ((char->integer c) . > . 127)
-                          ;; latex-prefix.rkt enables utf8 input, but this does not work for
+                          ;; first, try user-defined conversions
-                          ;; all the characters below (e.g. ∞). Some parts of the table
+                          (or (convs c)
-                          ;; below are therefore necessary, but some parts probably are not.
+                              ;; latex-prefix.rkt enables utf8 input, but this does not work for
-                          ;; Which parts are necessary may depend on the latex version,
+                              ;; all the characters below (e.g. ∞). Some parts of the table
-                          ;; though, so we keep this table around to avoid regressions.
+                              ;; below are therefore necessary, but some parts probably are not.
-                          (case c
+                              ;; Which parts are necessary may depend on the latex version,
-                            [(#\╔ #\═ #\╗ #\║ #\╚ #\╝ #\╦ #\╠ #\╣ #\╬ #\╩) (box-character c)]
+                              ;; though, so we keep this table around to avoid regressions.
-                            [(#\┌ #\─ #\┐ #\│ #\└ #\┘ #\┬ #\├ #\┤ #\┼ #\┴) (box-character c)]
+                              (case c
-                            [(#\┏ #\━ #\┓ #\┃ #\┗ #\┛ #\┳ #\┣ #\┫ #\╋ #\┻) (box-character c 2)]
+                                [(#\╔ #\═ #\╗ #\║ #\╚ #\╝ #\╦ #\╠ #\╣ #\╬ #\╩) (box-character c)]
-                            [(#\u2011) "\\mbox{-}"] ; non-breaking hyphen
+                                [(#\┌ #\─ #\┐ #\│ #\└ #\┘ #\┬ #\├ #\┤ #\┼ #\┴) (box-character c)]
-                            [(#\uB0) "$^{\\circ}$"] ; degree
+                                [(#\┏ #\━ #\┓ #\┃ #\┗ #\┛ #\┳ #\┣ #\┫ #\╋ #\┻) (box-character c 2)]
-                            [(#\uB2) "$^2$"]
+                                [(#\u2011) "\\mbox{-}"] ; non-breaking hyphen
-                            [(#\u039A) "K"] ; kappa
+                                [(#\uB0) "$^{\\circ}$"] ; degree
-                            [(#\u0391) "A"] ; alpha
+                                [(#\uB2) "$^2$"]
-                            [(#\u039F) "O"] ; omicron
+                                [(#\u039A) "K"] ; kappa
-                            [(#\u03A3) "$\\Sigma$"]
+                                [(#\u0391) "A"] ; alpha
-                            [(#\u03BA) "$\\kappa$"]
+                                [(#\u039F) "O"] ; omicron
-                            [(#\u03B1) "$\\alpha$"]
+                                [(#\u03A3) "$\\Sigma$"]
-                            [(#\u03B2) "$\\beta$"]
+                                [(#\u03BA) "$\\kappa$"]
-                            [(#\u03B3) "$\\gamma$"]
+                                [(#\u03B1) "$\\alpha$"]
-                            [(#\u03BF) "o"] ; omicron
+                                [(#\u03B2) "$\\beta$"]
-                            [(#\u03C3) "$\\sigma$"]
+                                [(#\u03B3) "$\\gamma$"]
-                            [(#\u03C2) "$\\varsigma$"]
+                                [(#\u03BF) "o"] ; omicron
-                            [(#\u03BB) "$\\lambda$"]
+                                [(#\u03C3) "$\\sigma$"]
-                            [(#\u039B) "$\\Lambda$"]
+                                [(#\u03C2) "$\\varsigma$"]
-                            [(#\u03BC) "$\\mu$"]
+                                [(#\u03BB) "$\\lambda$"]
-                            [(#\u03C0) "$\\pi$"]
+                                [(#\u039B) "$\\Lambda$"]
-                            [(#\ϖ) "$\\varpi$"]
+                                [(#\u03BC) "$\\mu$"]
-                            [(#\‘) "{`}"]
+                                [(#\u03C0) "$\\pi$"]
-                            [(#\’) "{'}"]
+                                [(#\‘) "{`}"]
-                            [(#\“) "{``}"]
+                                [(#\’) "{'}"]
-                            [(#\”) "{''}"]
+                                [(#\“) "{``}"]
-                            [(#\u2013) "{--}"]
+                                [(#\”) "{''}"]
-                            [(#\u2014) "{---}"]
+                                [(#\u2013) "{--}"]
-                            [(#\⟨ #\〈) "$\\langle$"] ; [MATHEMATICAL] LEFT ANGLE BRACKET
+                                [(#\u2014) "{---}"]
-                            [(#\⟩ #\〉) "$\\rangle$"] ; [MATHEMATICAL] RIGHT ANGLE BRACKET
+                                [(#\⟨ #\〈) "$\\langle$"] ; [MATHEMATICAL] LEFT ANGLE BRACKET
-                            [(#\∞) "$\\infty$"]
+                                [(#\⟩ #\〉) "$\\rangle$"] ; [MATHEMATICAL] RIGHT ANGLE BRACKET
-                            [(#\⇓) "$\\Downarrow$"]
+                                [(#\∞) "$\\infty$"]
-                            [(#\↖) "$\\nwarrow$"]
+                                [(#\⇓) "$\\Downarrow$"]
-                            [(#\↓) "$\\downarrow$"]
+                                [(#\↖) "$\\nwarrow$"]
-                            [(#\⇒) "$\\Rightarrow$"]
+                                [(#\↓) "$\\downarrow$"]
-                            [(#\→) "$\\rightarrow$"]
+                                [(#\⇒) "$\\Rightarrow$"]
-                            [(#\↘) "$\\searrow$"]
+                                [(#\→) "$\\rightarrow$"]
-                            [(#\↙) "$\\swarrow$"]
+                                [(#\↘) "$\\searrow$"]
-                            [(#\←) "$\\leftarrow$"]
+                                [(#\↙) "$\\swarrow$"]
-                            [(#\↑) "$\\uparrow$"]
+                                [(#\←) "$\\leftarrow$"]
-                            [(#\⇐) "$\\Leftarrow$"]
+                                [(#\↑) "$\\uparrow$"]
-                            [(#\−) "$\\longrightarrow$"]
+                                [(#\⇐) "$\\Leftarrow$"]
-                            [(#\⇑) "$\\Uparrow$"]
+                                [(#\−) "$\\longrightarrow$"]
-                            [(#\⇔) "$\\Leftrightarrow$"]
+                                [(#\⇑) "$\\Uparrow$"]
-                            [(#\↕) "$\\updownarrow$"]
+                                [(#\⇔) "$\\Leftrightarrow$"]
-                            [(#\↔) "$\\leftrightarrow$"]
+                                [(#\↕) "$\\updownarrow$"]
-                            [(#\↗) "$\\nearrow$"]
+                                [(#\↔) "$\\leftrightarrow$"]
-                            [(#\⇕) "$\\Updownarrow$"]
+                                [(#\↗) "$\\nearrow$"]
-                            [(#\א) "$\\aleph$"]
+                                [(#\⇕) "$\\Updownarrow$"]
-                            [(#\′) "$\\prime$"]
+                                [(#\א) "$\\aleph$"]
-                            [(#\∅) "$\\emptyset$"]
+                                [(#\′) "$\\prime$"]
-                            [(#\∇) "$\\nabla$"]
+                                [(#\∅) "$\\emptyset$"]
-                            [(#\♦) "$\\diamondsuit$"]
+                                [(#\∇) "$\\nabla$"]
-                            [(#\♠) "$\\spadesuit$"]
+                                [(#\♦) "$\\diamondsuit$"]
-                            [(#\♣) "$\\clubsuit$"]
+                                [(#\♠) "$\\spadesuit$"]
-                            [(#\♥) "$\\heartsuit$"]
+                                [(#\♣) "$\\clubsuit$"]
-                            [(#\♯) "$\\sharp$"]
+                                [(#\♥) "$\\heartsuit$"]
-                            [(#\♭) "$\\flat$"]
+                                [(#\♯) "$\\sharp$"]
-                            [(#\♮) "$\\natural$"]
+                                [(#\♭) "$\\flat$"]
-                            [(#\√) "$\\surd$"]
+                                [(#\♮) "$\\natural$"]
-                            [(#\∆) "$\\Delta$"] ; no better mapping for than \Delta for "increment"
+                                [(#\√) "$\\surd$"]
-                            [(#\u2211) "$\\sum$"] ; better than \Sigma, right?
+                                [(#\∆) "$\\Delta$"] ; no better mapping for than \Delta for "increment"
-                            [(#\u220F) "$\\prod$"] ; better than \Pi, right?
+                                [(#\u2211) "$\\sum$"] ; better than \Sigma, right?
-                            [(#\u2210) "$\\coprod$"]
+                                [(#\u220F) "$\\prod$"] ; better than \Pi, right?
-                            [(#\u222B) "$\\int$"]
+                                [(#\u2210) "$\\coprod$"]
-                            [(#\u222E) "$\\oint$"]
+                                [(#\u222B) "$\\int$"]
-                            [(#\¬) "$\\neg$"]
+                                [(#\u222E) "$\\oint$"]
-                            [(#\△) "$\\triangle$"]
+                                [(#\¬) "$\\neg$"]
-                            [(#\∀) "$\\forall$"]
+                                [(#\△) "$\\triangle$"]
-                            [(#\∃) "$\\exists$"]
+                                [(#\∀) "$\\forall$"]
-                            [(#\∘) "$\\circ$"]
+                                [(#\∃) "$\\exists$"]
-                            [(#\θ) "$\\theta$"]
+                                [(#\∘) "$\\circ$"]
-                            [(#\ϑ) "$\\vartheta$"]
+                                [(#\θ) "$\\theta$"]
-                            [(#\τ) "$\\tau$"]
+                                [(#\ϑ) "$\\vartheta$"]
-                            [(#\υ) "$\\upsilon$"]
+                                [(#\τ) "$\\tau$"]
-                            [(#\φ) "$\\phi$"]
+                                [(#\υ) "$\\upsilon$"]
-                            [(#\ϕ) "$\\varphi$"]
+                                [(#\φ) "$\\phi$"]
-                            [(#\δ) "$\\delta$"]
+                                [(#\ϕ) "$\\varphi$"]
-                            [(#\ρ) "$\\rho$"]
+                                [(#\δ) "$\\delta$"]
-                            [(#\ϱ) "$\\varrho$"]
+                                [(#\ρ) "$\\rho$"]
-                            [(#\ϵ) "$\\epsilon$"]
+                                [(#\ϱ) "$\\varrho$"]
-                            [(#\ε) "$\\varepsilon$"]
+                                [(#\ϵ) "$\\epsilon$"]
-                            [(#\χ) "$\\chi$"]
+                                [(#\ε) "$\\varepsilon$"]
-                            [(#\ψ) "$\\psi$"]
+                                [(#\ϖ) "$\\varpi$"]
-                            [(#\ζ) "$\\zeta$"]
+                                [(#\χ) "$\\chi$"]
-                            [(#\ν) "$\\nu$"]
+                                [(#\ψ) "$\\psi$"]
-                            [(#\ω) "$\\omega$"]
+                                [(#\ζ) "$\\zeta$"]
-                            [(#\η) "$\\eta$"]
+                                [(#\ν) "$\\nu$"]
-                            [(#\ι) "$\\iota$"]
+                                [(#\ω) "$\\omega$"]
-                            [(#\ξ) "$\\xi$"]
+                                [(#\η) "$\\eta$"]
-                            [(#\Γ) "$\\Gamma$"]
+                                [(#\ι) "$\\iota$"]
-                            [(#\Ψ) "$\\Psi$"]
+                                [(#\ξ) "$\\xi$"]
-                            [(#\Δ) "$\\Delta$"]
+                                [(#\Γ) "$\\Gamma$"]
-                            [(#\Ξ) "$\\Xi$"]
+                                [(#\Ψ) "$\\Psi$"]
-                            [(#\Υ) "$\\Upsilon$"]
+                                [(#\Δ) "$\\Delta$"]
-                            [(#\Ω) "$\\Omega$"]
+                                [(#\Ξ) "$\\Xi$"]
-                            [(#\Θ) "$\\Theta$"]
+                                [(#\Υ) "$\\Upsilon$"]
-                            [(#\Π) "$\\Pi$"]
+                                [(#\Ω) "$\\Omega$"]
-                            [(#\Φ) "$\\Phi$"]
+                                [(#\Θ) "$\\Theta$"]
-                            [(#\±) "$\\pm$"]
+                                [(#\Π) "$\\Pi$"]
-                            [(#\∩) "$\\cap$"]
+                                [(#\Φ) "$\\Phi$"]
-                            [(#\◇) "$\\diamond$"]
+                                [(#\±) "$\\pm$"]
-                            [(#\⊕) "$\\oplus$"]
+                                [(#\∩) "$\\cap$"]
-                            [(#\∓) "$\\mp$"]
+                                [(#\◇) "$\\diamond$"]
-                            [(#\∪) "$\\cup$"]
+                                [(#\⊕) "$\\oplus$"]
-                            [(#\△) "$\\bigtriangleup$"]
+                                [(#\∓) "$\\mp$"]
-                            [(#\⊖) "$\\ominus$"]
+                                [(#\∪) "$\\cup$"]
-                            [(#\×) "$\\times$"]
+                                [(#\△) "$\\bigtriangleup$"]
-                            [(#\⊎) "$\\uplus$"]
+                                [(#\⊖) "$\\ominus$"]
-                            [(#\▽) "$\\bigtriangledown$"]
+                                [(#\×) "$\\times$"]
-                            [(#\⊗) "$\\otimes$"]
+                                [(#\⊎) "$\\uplus$"]
-                            [(#\÷) "$\\div$"]
+                                [(#\▽) "$\\bigtriangledown$"]
-                            [(#\⊓) "$\\sqcap$"]
+                                [(#\⊗) "$\\otimes$"]
-                            [(#\▹) "$\\triangleleft$"]
+                                [(#\÷) "$\\div$"]
-                            [(#\⊘) "$\\oslash$"]
+                                [(#\⊓) "$\\sqcap$"]
-                            [(#\∗) "$\\ast$"]
+                                [(#\▹) "$\\triangleleft$"]
-                            [(#\⊔) "$\\sqcup$"]
+                                [(#\⊘) "$\\oslash$"]
-                            [(#\∨) "$\\vee$"]
+                                [(#\∗) "$\\ast$"]
-                            [(#\∧) "$\\wedge$"]
+                                [(#\⊔) "$\\sqcup$"]
-                            [(#\◃) "$\\triangleright$"]
+                                [(#\∨) "$\\vee$"]
-                            [(#\⊙) "$\\odot$"]
+                                [(#\∧) "$\\wedge$"]
-                            [(#\★) "$\\star$"]
+                                [(#\◃) "$\\triangleright$"]
-                            [(#\†) "$\\dagger$"]
+                                [(#\⊙) "$\\odot$"]
-                            [(#\•) "$\\bullet$"]
+                                [(#\★) "$\\star$"]
-                            [(#\‡) "$\\ddagger$"]
+                                [(#\†) "$\\dagger$"]
-                            [(#\≀) "$\\wr$"]
+                                [(#\•) "$\\bullet$"]
-                            [(#\⨿) "$\\amalg$"]
+                                [(#\‡) "$\\ddagger$"]
-                            [(#\≤) "$\\leq$"]
+                                [(#\≀) "$\\wr$"]
-                            [(#\≥) "$\\geq$"]
+                                [(#\⨿) "$\\amalg$"]
-                            [(#\≡) "$\\equiv$"]
+                                [(#\≤) "$\\leq$"]
-                            [(#\⊨) "$\\models$"]
+                                [(#\≥) "$\\geq$"]
-                            [(#\≺) "$\\prec$"]
+                                [(#\≡) "$\\equiv$"]
-                            [(#\≻) "$\\succ$"]
+                                [(#\⊨) "$\\models$"]
-                            [(#\∼) "$\\sim$"]
+                                [(#\≺) "$\\prec$"]
-                            [(#\⊥) "$\\perp$"]
+                                [(#\≻) "$\\succ$"]
-                            [(#\≼) "$\\preceq$"]
+                                [(#\∼) "$\\sim$"]
-                            [(#\≽) "$\\succeq$"]
+                                [(#\⊥) "$\\perp$"]
-                            [(#\≃) "$\\simeq$"]
+                                [(#\≼) "$\\preceq$"]
-                            [(#\≪) "$\\ll$"]
+                                [(#\≽) "$\\succeq$"]
-                            [(#\≫) "$\\gg$"]
+                                [(#\≃) "$\\simeq$"]
-                            [(#\≍) "$\\asymp$"]
+                                [(#\≪) "$\\ll$"]
-                            [(#\∥) "$\\parallel$"]
+                                [(#\≫) "$\\gg$"]
-                            [(#\⊂) "$\\subset$"]
+                                [(#\≍) "$\\asymp$"]
-                            [(#\⊃) "$\\supset$"]
+                                [(#\∥) "$\\parallel$"]
-                            [(#\≈) "$\\approx$"]
+                                [(#\⊂) "$\\subset$"]
-                            [(#\⋈) "$\\bowtie$"]
+                                [(#\⊃) "$\\supset$"]
-                            [(#\⊆) "$\\subseteq$"]
+                                [(#\≈) "$\\approx$"]
-                            [(#\⊇) "$\\supseteq$"]
+                                [(#\⋈) "$\\bowtie$"]
-                            [(#\≌) "$\\cong$"]
+                                [(#\⊆) "$\\subseteq$"]
-                            [(#\⊏) "$\\sqsubset$"]
+                                [(#\⊇) "$\\supseteq$"]
-                            [(#\⊐) "$\\sqsupset$"]
+                                [(#\≌) "$\\cong$"]
-                            [(#\≠) "$\\neq$"]
+                                [(#\⊏) "$\\sqsubset$"]
-                            [(#\⌣) "$\\smile$"]
+                                [(#\⊐) "$\\sqsupset$"]
-                            [(#\⊑) "$\\sqsubseteq$"]
+                                [(#\≠) "$\\neq$"]
-                            [(#\⊒) "$\\sqsupseteq$"]
+                                [(#\⌣) "$\\smile$"]
-                            [(#\≐) "$\\doteq$"]
+                                [(#\⊑) "$\\sqsubseteq$"]
-                            [(#\⌢) "$\\frown$"]
+                                [(#\⊒) "$\\sqsupseteq$"]
-                            [(#\∈) "$\\in$"]
+                                [(#\≐) "$\\doteq$"]
-                            [(#\∉) "$\\not\\in$"]
+                                [(#\⌢) "$\\frown$"]
-                            [(#\∋) "$\\ni$"]
+                                [(#\∈) "$\\in$"]
-                            [(#\∝) "$\\propto$"]
+                                [(#\∉) "$\\not\\in$"]
-                            [(#\⊢) "$\\vdash$"]
+                                [(#\∋) "$\\ni$"]
-                            [(#\⊣) "$\\dashv$"]    
+                                [(#\∝) "$\\propto$"]
-                            [(#\☠) "$\\skull$"]
+                                [(#\⊢) "$\\vdash$"]
-                            [(#\☺) "$\\smiley$"]
+                                [(#\⊣) "$\\dashv$"]    
-                            [(#\☻) "$\\blacksmiley$"]
+                                [(#\☠) "$\\skull$"]
-                            [(#\☹) "$\\frownie$"]
+                                [(#\☺) "$\\smiley$"]
-                            [(#\ø) "{\\o}"]
+                                [(#\☻) "$\\blacksmiley$"]
-                            [(#\Ø) "{\\O}"]
+                                [(#\☹) "$\\frownie$"]
-                            [(#\ł) "{\\l}"]
+                                [(#\ø) "{\\o}"]
-                            [(#\Ł) "{\\L}"]
+                                [(#\Ø) "{\\O}"]
-                            [(#\uA7) "{\\S}"]
+                                [(#\ł) "{\\l}"]
-                            [(#\⟦ #\〚) "$[\\![$"]
+                                [(#\Ł) "{\\L}"]
-                            [(#\⟧ #\〛) "$]\\!]$"]
+                                [(#\uA7) "{\\S}"]
-                            [(#\↦) "$\\mapsto$"]
+                                [(#\⟦ #\〚) "$[\\![$"]
-                            [(#\⊤) "$\\top$"]
+                                [(#\⟧ #\〛) "$]\\!]$"]
-                            [(#\¥) "{\\textyen}"]
+                                [(#\↦) "$\\mapsto$"]
-                            [(#\™) "{\\texttrademark}"]
+                                [(#\⊤) "$\\top$"]
-                            [(#\®) "{\\textregistered}"]
+                                [(#\¥) "{\\textyen}"]
-                            [(#\©) "{\\textcopyright}"]
+                                [(#\™) "{\\texttrademark}"]
-                            [(#\u2070) "$^0$"]
+                                [(#\®) "{\\textregistered}"]
-                            [(#\u00b9) "$^1$"]
+                                [(#\©) "{\\textcopyright}"]
-                            [(#\u00b2) "$^2$"]
+                                [(#\u2070) "$^0$"]
-                            [(#\u00b3) "$^3$"]
+                                [(#\u00b9) "$^1$"]
-                            [(#\u2074) "$^4$"]
+                                [(#\u00b2) "$^2$"]
-                            [(#\u2075) "$^5$"]
+                                [(#\u00b3) "$^3$"]
-                            [(#\u2076) "$^6$"]
+                                [(#\u2074) "$^4$"]
-                            [(#\u2077) "$^7$"]
+                                [(#\u2075) "$^5$"]
-                            [(#\u2078) "$^8$"]
+                                [(#\u2076) "$^6$"]
-                            [(#\u2079) "$^9$"]
+                                [(#\u2077) "$^7$"]
-                            [(#\u207a) "$^+$"]
+                                [(#\u2078) "$^8$"]
-                            [(#\u207b) "$^-$"]
+                                [(#\u2079) "$^9$"]
-                            [(#\⋖) "$\\precdot$"]
+                                [(#\u207a) "$^+$"]
-                            [(#\⋗) "$\\succdot$"]
+                                [(#\u207b) "$^-$"]
-                            [(#\⋮) "\\vdots"]
+                                [(#\⋖) "$\\precdot$"]
-                            [(#\⋱) "$\\ddots$"]
+                                [(#\⋗) "$\\succdot$"]
-                            [(#\⋯) "$\\cdots$"]
+                                [(#\⋮) "\\vdots"]
-                            [(#\⋯) "\\hdots"]
+                                [(#\⋱) "$\\ddots$"]
-                            [else
+                                [(#\⋯) "$\\cdots$"]
-                             (cond
+                                [(#\⋯) "\\hdots"]
-                              [(char<=? #\uAC00 c #\uD7AF) ; Korean Hangul
+                                [else
-                               (format "\\begin{CJK}{UTF8}{mj}~a\\end{CJK}" c)]
+                                 (cond
-                              [else
+                                  [(char<=? #\uAC00 c #\uD7AF) ; Korean Hangul
-                               ;; Detect characters that can be formed with combining characters
+                                   (format "\\begin{CJK}{UTF8}{mj}~a\\end{CJK}" c)]
-                               ;; and translate them to Latex combinations:
+                                  [else
-                               (define s (string-normalize-nfd (string c)))
+                                   ;; Detect characters that can be formed with combining characters
-                               (define len (string-length s))
+                                   ;; and translate them to Latex combinations:
-                               (cond
+                                   (define s (string-normalize-nfd (string c)))
-                                [(len . > . 1)
+                                   (define len (string-length s))
-                                 (define combiner (case (string-ref s (sub1 len))
+                                   (cond
-                                                    [(#\u300) "\\`{~a}"]
+                                    [(len . > . 1)
-                                                    [(#\u301) "\\'{~a}"]
+                                     (define combiner (case (string-ref s (sub1 len))
-                                                    [(#\u302) "\\^{~a}"]
+                                                        [(#\u300) "\\`{~a}"]
-                                                    [(#\u303) "\\~~{~a}"]
+                                                        [(#\u301) "\\'{~a}"]
-                                                    [(#\u304) "\\={~a}"]
+                                                        [(#\u302) "\\^{~a}"]
-                                                    [(#\u306) "\\u{~a}"]
+                                                        [(#\u303) "\\~~{~a}"]
-                                                    [(#\u307) "\\.{~a}"]
+                                                        [(#\u304) "\\={~a}"]
-                                                    [(#\u308) "\\\"{~a}"]
+                                                        [(#\u306) "\\u{~a}"]
-                                                    [(#\u30a) "\\r{~a}"]
+                                                        [(#\u307) "\\.{~a}"]
-                                                    [(#\u30b) "\\H{~a}"]
+                                                        [(#\u308) "\\\"{~a}"]
-                                                    [(#\u30c) "\\v{~a}"]
+                                                        [(#\u30a) "\\r{~a}"]
-                                                    [(#\u327) "\\c{~a}"]
+                                                        [(#\u30b) "\\H{~a}"]
-                                                    [(#\u328) "\\k{~a}"]
+                                                        [(#\u30c) "\\v{~a}"]
-                                                    [else #f]))
+                                                        [(#\u327) "\\c{~a}"]
-                                 (define base (string-normalize-nfc (substring s 0 (sub1 len))))
+                                                        [(#\u328) "\\k{~a}"]
-                                 (if (and combiner
+                                                        [else #f]))
-                                          (= 1 (string-length base)))
+                                     (define base (string-normalize-nfc (substring s 0 (sub1 len))))
-                                     (format combiner (char-loop (string-ref base 0)))
+                                     (if (and combiner
-                                     c)]
+                                              (= 1 (string-length base)))
-                                [else c])])])
+                                         (format combiner (char-loop (string-ref base 0)))
+                                         c)]
+                                    [else c])])]))
                           c)])))
                 (loop (add1 i))))))]))
     

scribble-lib/scribble/manual-struct.rkt

@@ -5,6 +5,8 @@
 
 (provide-structs
  [module-path-index-desc ()]
+ [(language-index-desc module-path-index-desc) ()]
+ [(reader-index-desc module-path-index-desc) ()]
  [exported-index-desc ([name symbol?]
                        [from-libs (listof module-path?)])]
  [(method-index-desc exported-index-desc) ([method-name symbol?]

scribble-lib/scribble/manual-style.css

@@ -356,7 +356,10 @@ a:hover {
     .refcolumn {
         position: absolute;
         left: 66rem; right: 3em;
-        margin: 0;
+        margin-top: -1.2em;
+        margin-right: 0;
+        margin-bottom: 0;
+        margin-left: 0;
         float: right;
         max-width: 18rem;
     }

scribble-lib/scribble/private/manual-bind.rkt

@@ -114,7 +114,15 @@
                                 (let ([ns-id 
                                        (let ([ns (make-base-empty-namespace)])
                                          (parameterize ([current-namespace ns])
-                                           (namespace-require `(for-label ,lib))
+                                           ;; A `(namespace-require `(for-label ,lib))` can
+                                           ;; fail if `lib` provides different bindings of the
+                                           ;; same name at different phases. We can require phases
+                                           ;; 1 and 0 separately, in which case the phase-0
+                                           ;; binding shadows the phase-1 one in that case.
+                                           ;; This strategy only works for documenting bindings
+                                           ;; at phases 0 and 1, though.
+                                           (namespace-require `(just-meta 1 (for-label ,lib)))
+                                           (namespace-require `(just-meta 0 (for-label ,lib)))
                                            (namespace-syntax-introduce (datum->syntax #f 'x))))])
                                   (let ([checker
                                          (lambda (id)

scribble-lib/scribble/private/manual-mod.rkt

@@ -221,30 +221,36 @@
                                    (add-between (map tt pkgs) ", "))))))))))
     (define (flow-width f) (apply max (map block-width f)))
     (define libs-specs
+      ;; make-desc  : element -> flow
+      ;; index-desc : module-path-index-desc
+      (let-values ([(make-desc index-desc)
+                    (case lang
+                      [(#f)
+                       (values (lambda (modname) (list (racket (#,req #,modname))))
+                               the-module-path-index-desc)]
+                      [(#t)
+                       (values (lambda (modname) (list (hash-lang) spacer modname))
+                               the-language-index-desc)]
+                      [(reader)
+                       (values (lambda (modname) (list (racketmetafont "#reader") spacer modname))
+                               the-reader-index-desc)]
+                      [(just-lang)
+                       (values (lambda (modname) (list (hash-lang) spacer modname))
+                               the-language-index-desc)]
+                      [else (error 'defmodule "unknown mode: ~e" lang)])])
       (map
        (lambda (name modpath)
          (define modname (if link-target?
-                             (make-defracketmodname name modpath)
+                             (make-defracketmodname name modpath index-desc)
                              name))
          (list
           (make-flow
            (list
             (make-omitable-paragraph
-             (cons
+             (cons spacer (make-desc modname)))))
-              spacer
-              (case lang
-                [(#f)
-                 (list (racket (#,req #,modname)))]
-                [(#t)
-                 (list (hash-lang) spacer modname)]
-                [(reader)
-                 (list (racketmetafont "#reader") spacer modname)]
-                [(just-lang)
-                 (list (hash-lang) spacer modname)]
-                [else (error 'defmodule "unknown mode: ~e" lang)])))))
           'cont))
        names
-       modpaths))
+       modpaths)))
 
     (make-splice
      (cons
@@ -278,8 +284,10 @@
               (flow-paragraphs (decode-flow content)))))))
 
 (define the-module-path-index-desc (make-module-path-index-desc))
+(define the-language-index-desc (make-language-index-desc))
+(define the-reader-index-desc (make-reader-index-desc))
 
-(define (make-defracketmodname mn mp)
+(define (make-defracketmodname mn mp index-desc)
   (let ([name-str (datum-intern-literal (element->string mn))]
         [path-str (datum-intern-literal (element->string mp))])
     (make-index-element #f
@@ -287,7 +295,7 @@
                         (intern-taglet `(mod-path ,path-str))
                         (list name-str)
                         (list mn)
-                        the-module-path-index-desc)))
+                        index-desc)))
 
 (define-syntax (declare-exporting stx)
   (syntax-parse stx

scribble-test/tests/scribble/markdown-docs/example.md

@@ -81,17 +81,14 @@ Examples:
 
 ```racket
 > (define x 0) 
-               
 > (displayln x)
 0              
-               
 ```
 
 Example of Scribble `interaction`:
 
 ```racket
 > (define x 0)
-              
 > x           
 0             
 ```