defmodulelang and schememodlink changes to split lang text and module path

svn: r15619

collects/scribble/private/manual-mod.ss

@@ -11,7 +11,9 @@
          (for-syntax scheme/base)
          (for-label scheme/base))
 
-(provide defmodule defmodule* defmodulelang defmodulelang* defmodulereader defmodulereader*
+(provide defmodule defmodule* 
+         defmodulelang defmodulelang* 
+         defmodulereader defmodulereader*
          defmodule*/no-declare defmodulelang*/no-declare defmodulereader*/no-declare
          declare-exporting)
 
@@ -21,6 +23,7 @@
   (syntax-rules ()
     [(_ #:require-form req (name ...) . content)
      (*defmodule (list (schememodname name) ...)
+                 #f
                  #f
                  (list . content)
                  req)]
@@ -46,22 +49,34 @@
     [(_ name . content)
      (defmodule* (name) . content)]))
 
-(define-syntax-rule (defmodulelang*/no-declare (lang ...) . content)
+(define-syntax defmodulelang*/no-declare
-  (*defmodule (list (schememodname lang) ...) #t (list . content) #f))
+  (syntax-rules ()
+    [(_ (lang ...) #:module-paths (modpath ...) . content)
+     (*defmodule (list lang ...) (list (schememodname modpath) ...) #t (list . content) #f)]
+    [(_ (lang ...) . content)
+     (*defmodule (list (schememodname lang) ...) #f #t (list . content) #f)]))
 
 (define-syntax defmodulelang*
   (syntax-rules ()
+    [(_ (name ...) #:module-paths (modpath ...) #:use-sources (pname ...) . content)
+     (begin (declare-exporting modpath ... #:use-sources (pname ...))
+            (defmodulelang*/no-declare (name ...) #:module-paths (modpath ...) . content))]
+    [(_ (name ...) #:module-paths (modpath ...) . content)
+     (defmodulelang* (name ...) #:module-paths (modpath ...) #:use-sources () . content)]
     [(_ (name ...) #:use-sources (pname ...) . content)
-     (begin (declare-exporting name ... #:use-sources (pname ...))
+     (defmodulelang* ((schememodname name) ...) #:module-paths (name ...) #:use-sources (pname ...) . content)]
-            (defmodulelang*/no-declare (name ...) . content))]
     [(_ (name ...) . content)
      (defmodulelang* (name ...) #:use-sources () . content)]))
 
-(define-syntax-rule (defmodulelang lang . content)
+(define-syntax defmodulelang
-  (defmodulelang* (lang) . content))
+  (syntax-rules ()
+    [(_ lang #:module-path modpath . content)
+     (defmodulelang* (lang) #:module-paths (modpath) . content)]
+    [(_ lang . content)
+     (defmodulelang* (lang) . content)]))
 
 (define-syntax-rule (defmodulereader*/no-declare (lang ...) . content)
-  (*defmodule (list (schememodname lang) ...) 'reader (list . content) #f))
+  (*defmodule (list (schememodname lang) ...) #f 'reader (list . content) #f))
 
 (define-syntax defmodulereader*
   (syntax-rules ()
@@ -74,35 +89,42 @@
 (define-syntax-rule (defmodulereader lang . content)
   (defmodulereader* (lang) . content))
 
-(define (*defmodule names lang content req)
+(define (*defmodule names modpaths lang content req)
+  (let ([modpaths (or modpaths names)])
     (make-splice
      (cons
       (make-table
        "defmodule"
        (map
-      (lambda (name)
+        (lambda (name modpath)
           (list
            (make-flow
             (list
              (make-omitable-paragraph
               (cons
                spacer
-             (if lang
+               (case lang
-                 (if (eq? lang 'reader)
+                 [(#f)
-                     (list (schememetafont "#reader") spacer (make-defschememodname name))
+                  (list (scheme (#,req #,(make-defschememodname name modpath))))]
-                     (list (hash-lang) spacer (make-defschememodname name)))
+                 [(#t)
-                 (list (scheme (#,req #,(make-defschememodname name)))))))))))
+                  (list (hash-lang) spacer (make-defschememodname name modpath))]
-      names))
+                 [(reader)
-    (append (map (lambda (name)
+                  (list (schememetafont "#reader") spacer (make-defschememodname name modpath))]
-                   (make-part-tag-decl `(mod-path ,(element->string name))))
+                 [(just-lang)
-                 names)
+                  (list (hash-lang) spacer (make-defschememodname name modpath))])))))))
-            (flow-paragraphs (decode-flow content))))))
+        names
+        modpaths))
+      (append (map (lambda (modpath)
+                     (make-part-tag-decl `(mod-path ,(element->string modpath))))
+                   modpaths)
+              (flow-paragraphs (decode-flow content)))))))
 
-(define (make-defschememodname mn)
+(define (make-defschememodname mn mp)
-  (let ([name-str (element->string mn)])
+  (let ([name-str (element->string mn)]
+        [path-str (element->string mp)])
     (make-index-element #f
                         (list mn)
-                        `(mod-path ,name-str)
+                        `(mod-path ,path-str)
                         (list name-str)
                         (list mn)
                         (make-module-path-index-desc))))

collects/scribble/private/manual-scheme.ss

@@ -15,7 +15,8 @@
          schemeblockelem
          schemeinput
          schememod
-         scheme SCHEME scheme/form schemeresult schemeid schememodname
+         scheme SCHEME scheme/form schemeresult schemeid 
+         schememodname schememodlink
          indexed-scheme
          schemelink)
 
@@ -104,12 +105,20 @@
     [(schememodname n)
      (as-modname-link 'n (*schememodname n))]))
 
+(define-syntax schememodlink
+  (syntax-rules (unsyntax)
+    [(schememodlink n content ...)
+     (*as-modname-link 'n (elem #:style #f content ...))]))
+
 (define (as-modname-link s e)
   (if (symbol? s)
+      (*as-modname-link s e)
+      e))
+
+(define (*as-modname-link s e)
   (make-link-element module-link-color
                      (list e)
-                       `(mod-path ,(symbol->string s)))
+                     `(mod-path ,(format "~s" s))))
-    e))
 
 (define-syntax-rule (indexed-scheme x)
   (add-scheme-index 'x (scheme x)))

collects/scribblings/scribble/manual.scrbl

@@ -163,6 +163,11 @@ is an identifier or @scheme[expr] produces a symbol, then it is
 hyperlinked to the module path's definition as created by
 @scheme[defmodule].}
 
+@defform[(schememodlink datum pre-content-expr ...)]{
+Like @scheme[schememodlink], but separating the module path to link
+from the content to be linked. The @scheme[datum] module path is always
+linked, even if it is not an identifier.}
+
 @defproc[(litchar [str string?]) element?]{Typesets @scheme[str] as a
 representation of literal text. Use this when you have to talk about
 the individual characters in a stream of text, as as when documenting
@@ -284,11 +289,15 @@ Hyperlinks created by @scheme[schememodname] are associated with the
 enclosing section, rather than the local @scheme[id] text.}
 
 
-@defform[(defmodulelang id maybe-sources pre-flow ...)]{
+@defform*[[(defmodulelang id maybe-sources pre-flow ...)
+           (defmodulelang content-expr #:module-paths (mod-path ...) 
+                          maybe-sources pre-flow ...)]]{
 
 Like @scheme[defmodule], but documents @scheme[id] as a module path
-suitable for use by either @scheme[require] or @schememodfont{#lang}.}
+suitable for use by either @scheme[require] or @hash-lang[].  If the
-
+module path for @scheme[require] is syntactically different from the
+@hash-lang[] form, use the @scheme[#:module-paths] to provide them
+separately.}
 
 @defform[(defmodulereader id maybe-sources pre-flow ...)]{
 
@@ -298,7 +307,9 @@ suitable for use with @schememetafont{#reader}.}
 
 @deftogether[(
 @defform[(defmodule* maybe-req  (id ...+) maybe-sources pre-flow ...)]
-@defform[(defmodulelang* (id ...+) maybe-sources pre-flow ...)]
+@defform*[[(defmodulelang* (id ...+) maybe-sources pre-flow ...)
+           (defmodulelang* (content-expr ...+) #:module-paths (mod-path ...+) 
+                           maybe-sources pre-flow ...)]]
 @defform[(defmodulereader* (id ...+) maybe-sources pre-flow ...)]
 )]{
 
@@ -307,7 +318,9 @@ of just one.}
 
 @deftogether[(
 @defform[(defmodule*/no-declare maybe-req (id ...) pre-flow ...)]
-@defform[(defmodulelang*/no-declare (id ...) pre-flow ...)]
+@defform*[[(defmodulelang*/no-declare (id ...) pre-flow ...)
+           (defmodulelang*/no-declare (content-expr ...) 
+                                      #:module-paths (mod-path ...+) pre-flow ...)]]
 @defform[(defmodulereader*/no-declare (id ...) pre-flow ...)]
 )]{