Downcase more symbols and constants.

diff --git a/src/edwin/edwin.ldr b/src/edwin/edwin.ldr
index 7897e2ea99728690a4dc8b6b9fa8037c063ab18f..698afde886243eb3f17604cb69b5fdb1f93529ea 100644 (file)
--- a/src/edwin/edwin.ldr
+++ b/src/edwin/edwin.ldr
@@ -33,7 +33,7 @@ USA.
   (let ((to-avoid-list (if (file-exists? "edwin.bad")
                           (fasload "edwin.bad")
                           '()))
-       (bad-environment-tag '*BAD-ENVIRONMENT*))
+       (bad-environment-tag '*bad-environment*))
     (let ((->environment
           (lambda (spec)
             (if (name->package spec)
@@ -70,56 +70,56 @@ USA.
       (define string-member? (member-procedure string=?))
       (define (boolean-and a b) (and a b))
 
-      (if (memq (lookup 'OS-TYPE) '(UNIX NT))
+      (if (memq (lookup 'os-type) '(unix nt))
          (begin
-           (load-option 'SUBPROCESS)
-           (load-option 'SYNCHRONOUS-SUBPROCESS)))
-      (load-option 'RB-TREE)
-      (load-option 'HASH-TABLE)
-      (load-option 'REGULAR-EXPRESSION)
-      (load-option 'MIME-CODEC)
+           (load-option 'subprocess)
+           (load-option 'synchronous-subprocess)))
+      (load-option 'rb-tree)
+      (load-option 'hash-table)
+      (load-option 'regular-expression)
+      (load-option 'mime-codec)
 
-      (let ((environment (->environment '(EDWIN))))
+      (let ((environment (->environment '(edwin))))
        (load "utils" environment)
-       (load "string" (->environment '(EDWIN STRING)))
+       (load "string" (->environment '(edwin string)))
        (load "nvector" environment)
        (load "ring" environment)
        (load "strtab" environment)
        (load "strpad" environment)
-       (load "macros" (->environment '(EDWIN MACROS)))
+       (load "macros" (->environment '(edwin macros)))
        (load "class" environment)
-       (load "clscon" (->environment '(EDWIN CLASS-CONSTRUCTOR)))
-       (load "clsmac" (->environment '(EDWIN CLASS-MACROS)))
+       (load "clscon" (->environment '(edwin class-constructor)))
+       (load "clsmac" (->environment '(edwin class-macros)))
        (load "xform"
              (->environment
-              '(EDWIN CLASS-MACROS TRANSFORM-INSTANCE-VARIABLES)))
+              '(edwin class-macros transform-instance-variables)))
        (load "paths" environment)
        (load "struct" environment)
-       (load "grpops" (->environment '(EDWIN GROUP-OPERATIONS)))
-       (load "txtprp" (->environment '(EDWIN TEXT-PROPERTIES)))
+       (load "grpops" (->environment '(edwin group-operations)))
+       (load "txtprp" (->environment '(edwin text-properties)))
        (load "regops" environment)
        (load "motion" environment)
        (load "search" environment)
        (load "image" environment)
        (load "comman" environment)
        (load "docstr" environment)
-       (if (not (memq (lookup 'OS-TYPE) '(DOS NT)))
+       (if (not (memq (lookup 'os-type) '(dos nt)))
            (set! (access *external-doc-strings?* environment) #f))
-       (load "comtab" (->environment '(EDWIN COMTAB)))
+       (load "comtab" (->environment '(edwin comtab)))
        (load "modes" environment)
        (load "buffer" environment)
        (load "bufset" environment)
-       (load "display" (->environment '(EDWIN DISPLAY-TYPE)))
-       (load "screen" (->environment '(EDWIN SCREEN)))
+       (load "display" (->environment '(edwin display-type)))
+       (load "screen" (->environment '(edwin screen)))
 
-       (let ((environment (->environment '(EDWIN WINDOW))))
+       (let ((environment (->environment '(edwin window))))
          (load "window" environment)
          (load "utlwin" environment)
          (load "bufwin" environment)
          (load "bufwfs" environment)
          (load "bufwiu" environment)
          (load "bufwmc" environment)
-         (load "comwin" (->environment '(EDWIN WINDOW COMBINATION)))
+         (load "comwin" (->environment '(edwin window combination)))
          (load "modwin" environment)
          (load "buffrm" environment)
          (load "edtfrm" environment))
@@ -129,81 +129,81 @@ USA.
        (load "editor" environment)
        (load "curren" environment)
        ;; "undo" must be loaded after "editor":
-       (load "undo" (->environment '(EDWIN UNDO)))
+       (load "undo" (->environment '(edwin undo)))
        (load "simple" environment)
        (load "debuge" environment)
-       (load "modlin" (->environment '(EDWIN MODELINE-STRING)))
-       (load "input" (->environment '(EDWIN KEYBOARD)))
-       (load "prompt" (->environment '(EDWIN PROMPT)))
-       (load "comred" (->environment '(EDWIN COMMAND-READER)))
-       (load "bufinp" (->environment '(EDWIN BUFFER-INPUT-PORT)))
-       (load "bufout" (->environment '(EDWIN BUFFER-OUTPUT-PORT)))
-       (load "winout" (->environment '(EDWIN WINDOW-OUTPUT-PORT)))
+       (load "modlin" (->environment '(edwin modeline-string)))
+       (load "input" (->environment '(edwin keyboard)))
+       (load "prompt" (->environment '(edwin prompt)))
+       (load "comred" (->environment '(edwin command-reader)))
+       (load "bufinp" (->environment '(edwin buffer-input-port)))
+       (load "bufout" (->environment '(edwin buffer-output-port)))
+       (load "winout" (->environment '(edwin window-output-port)))
        (load "things" environment)
        (load "tparse" environment)
        (load "syntax" environment)
-       (load "regexp" (->environment '(EDWIN REGULAR-EXPRESSION)))
+       (load "regexp" (->environment '(edwin regular-expression)))
        (load "comatch" environment)
-       (load "keyparse" (->environment '(EDWIN KEYPARSER)))
-       (load "linden" (->environment '(EDWIN LISP-INDENTATION)))
+       (load "keyparse" (->environment '(edwin keyparser)))
+       (load "linden" (->environment '(edwin lisp-indentation)))
 
-       (case (lookup 'OS-TYPE)
-         ((UNIX)
+       (case (lookup 'os-type)
+         ((unix)
           (load "unix" environment))
-         ((DOS NT)
+         ((dos nt)
           (load "dos" environment)
           (load "dosfile" environment)))
 
        (load "fileio" environment)
 
-       (let ((env (->environment '(EDWIN SCREEN CONSOLE-SCREEN))))
+       (let ((env (->environment '(edwin screen console-screen))))
          (load-set-and-initialize! '("termcap" "tterm") env)
-         (if (memq (lookup 'OS-TYPE) '(DOS NT))
+         (if (memq (lookup 'os-type) '(dos nt))
              (begin
                (load "ansi" env)
                (if (load "bios" env)
                    ((access bios-initialize-package! env))))))
 
-        (case (lookup 'OS-TYPE)
-         ((NT)
+        (case (lookup 'os-type)
+         ((nt)
           (load-set-and-initialize! '("win32")
-                                    (->environment '(EDWIN SCREEN WIN32)))
+                                    (->environment '(edwin screen win32)))
           (load-set-and-initialize! '("key-w32")
-                                    (->environment '(EDWIN WIN32-KEYS))))
-         ((UNIX)
+                                    (->environment '(edwin win32-keys))))
+         ((unix)
           (load-set-and-initialize! '("xterm")
-                                    (->environment '(EDWIN SCREEN X-SCREEN)))
-          (load "key-x11" (->environment '(EDWIN X-KEYS)))))
+                                    (->environment '(edwin screen x-screen)))
+          (load "key-x11" (->environment '(edwin x-keys)))))
 
-       (load-case 'OS-TYPE
-                  '((UNIX . "process")
-                    (DOS . "dosproc")
-                    (NT . "process"))
-                  (->environment '(EDWIN PROCESS)))
+       (load-case 'os-type
+                  '((unix . "process")
+                    (dos . "dosproc")
+                    (nt . "process"))
+                  (->environment '(edwin process)))
 
        (load "mousecom" environment)
-        (case (lookup 'OS-TYPE)
-         ((UNIX) (load "xcom" (->environment '(EDWIN X-COMMANDS))))
-         ((NT) (load "win32com" (->environment '(EDWIN WIN-COMMANDS)))))
+        (case (lookup 'os-type)
+         ((unix) (load "xcom" (->environment '(edwin x-commands))))
+         ((nt) (load "win32com" (->environment '(edwin win-commands)))))
        ;; debug depends on button1-down defined in mousecom
-       (load "debug" (->environment '(EDWIN DEBUGGER)))
+       (load "debug" (->environment '(edwin debugger)))
 
-       (let ((env (->environment '(EDWIN DIRED))))
+       (let ((env (->environment '(edwin dired))))
          (load "dired" env)
-         (case (lookup 'OS-TYPE)
-           ((UNIX) (load "dirunx" env))
-           ((NT) (load "dirw32" env))))
+         (case (lookup 'os-type)
+           ((unix) (load "dirunx" env))
+           ((nt) (load "dirw32" env))))
 
        (load "abbrev" environment)
-       (load "argred" (->environment '(EDWIN COMMAND-ARGUMENT)))
+       (load "argred" (->environment '(edwin command-argument)))
        (load "autold" environment)
        (load "autosv" environment)
        (load "basic" environment)
        (load "bufcom" environment)
-       (load "bufmnu" (->environment '(EDWIN BUFFER-MENU)))
+       (load "bufmnu" (->environment '(edwin buffer-menu)))
        (load "c-mode" environment)
        (load "javamode" environment)
-       (load "cinden" (->environment '(EDWIN C-INDENTATION)))
+       (load "cinden" (->environment '(edwin c-indentation)))
        (load "comhst" environment)
        (load "comint" environment)
        (load "compile" environment)
@@ -212,48 +212,48 @@ USA.
        (load "filcom" environment)
        (load "fill" environment)
        (load "hlpcom" environment)
-       (load "info" (->environment '(EDWIN INFO)))
-       (load "intmod" (->environment '(EDWIN INFERIOR-REPL)))
-       (load "keymap" (->environment '(EDWIN COMMAND-SUMMARY)))
+       (load "info" (->environment '(edwin info)))
+       (load "intmod" (->environment '(edwin inferior-repl)))
+       (load "keymap" (->environment '(edwin command-summary)))
        (load "kilcom" environment)
        (load "kmacro" environment)
        (load "lincom" environment)
        (load "lspcom" environment)
-       (load "malias" (->environment '(EDWIN MAIL-ALIAS)))
+       (load "malias" (->environment '(edwin mail-alias)))
        (load "motcom" environment)
-       (load "occur" (->environment '(EDWIN OCCURRENCE)))
+       (load "occur" (->environment '(edwin occurrence)))
        (load "outline" environment)
-       ;;(load "rcs" (->environment '(EDWIN RCS)))
-       (load "reccom" (->environment '(EDWIN RECTANGLE)))
-       (load "regcom" (->environment '(EDWIN REGISTER-COMMAND)))
+       ;;(load "rcs" (->environment '(edwin rcs)))
+       (load "reccom" (->environment '(edwin rectangle)))
+       (load "regcom" (->environment '(edwin register-command)))
        (load "replaz" environment)
-       (load "rfc822" (->environment '(EDWIN RFC822)))
-       (load "rmail" (->environment '(EDWIN RMAIL)))
-       (load "rmailsum" (->environment '(EDWIN RMAIL)))
-       (load "rmailsrt" (->environment '(EDWIN RMAIL)))
+       (load "rfc822" (->environment '(edwin rfc822)))
+       (load "rmail" (->environment '(edwin rmail)))
+       (load "rmailsum" (->environment '(edwin rmail)))
+       (load "rmailsrt" (->environment '(edwin rmail)))
        (load "schmod" environment)
-       (load "sendmail" (->environment '(EDWIN SENDMAIL)))
+       (load "sendmail" (->environment '(edwin sendmail)))
        (load "sercom" environment)
-       (load "iserch" (->environment '(EDWIN INCREMENTAL-SEARCH)))
+       (load "iserch" (->environment '(edwin incremental-search)))
        (load "shell" environment)
-       (load "tagutl" (->environment '(EDWIN TAGS)))
+       (load "tagutl" (->environment '(edwin tags)))
        (load "texcom" environment)
        (load "htmlmode" environment)
-        (load "diff" (->environment '(EDWIN DIFF)))
-       (load "rcsparse" (->environment '(EDWIN RCS-PARSE)))
-       (load "vc" (->environment '(EDWIN VC)))
-       (load "vc-rcs" (->environment '(EDWIN VC)))
-       (load "vc-cvs" (->environment '(EDWIN VC)))
-       (load "vc-svn" (->environment '(EDWIN VC)))
-       (load "vc-bzr" (->environment '(EDWIN VC)))
-       (load "vc-git" (->environment '(EDWIN VC)))
+        (load "diff" (->environment '(edwin diff)))
+       (load "rcsparse" (->environment '(edwin rcs-parse)))
+       (load "vc" (->environment '(edwin vc)))
+       (load "vc-rcs" (->environment '(edwin vc)))
+       (load "vc-cvs" (->environment '(edwin vc)))
+       (load "vc-svn" (->environment '(edwin vc)))
+       (load "vc-bzr" (->environment '(edwin vc)))
+       (load "vc-git" (->environment '(edwin vc)))
        (load "wincom" environment)
        (load "scrcom" environment)
        (load "modefs" environment)
        (load "loadef" environment)
        #|
        (load-set-and-initialize! '("bochser" "bochsmod")
-                                 (->environment '(EDWIN BOCHSER)))
+                                 (->environment '(edwin bochser)))
        |#
        (load "notify" environment)
        (load "world-monitor" environment)

diff --git a/src/edwin/edwin.sf b/src/edwin/edwin.sf
index b0ddb5f0ccf7dca5ddef7dd993f7f955a6290232..1f45ba3d73d5fda1ddfc5846401fe31f60cdbe1f 100644 (file)
--- a/src/edwin/edwin.sf
+++ b/src/edwin/edwin.sf
@@ -24,23 +24,23 @@ USA.
 
 |#
 
-(load-option 'CREF)
+(load-option 'cref)
 
-(if (not (name->package '(EDWIN)))
+(if (not (name->package '(edwin)))
     (let ((package-set (package-set-pathname "edwin")))
       (if (not (file-exists? package-set))
          (cref/generate-trivial-constructor "edwin"))
       (construct-packages-from-file (fasload package-set))))
 
-(if (lexical-unreferenceable? (->environment '(EDWIN STRING))
-                             'STRING?)
+(if (lexical-unreferenceable? (->environment '(edwin string))
+                             'string?)
     (begin
-      (fluid-let ((sf/default-syntax-table (->environment '(EDWIN))))
+      (fluid-let ((sf/default-syntax-table (->environment '(edwin))))
        (sf-conditionally "string"))
-      (load "string.bin" '(EDWIN STRING))))
+      (load "string.bin" '(edwin string))))
 
-(if (lexical-unreferenceable? (->environment '(EDWIN CLASS-CONSTRUCTOR))
-                             'CLASS-DESCRIPTORS)
+(if (lexical-unreferenceable? (->environment '(edwin class-constructor))
+                             'class-descriptors)
     (begin
       (let ((sf-and-load
             (lambda (files package)
@@ -49,12 +49,12 @@ USA.
               (for-each (lambda (file)
                           (load (string-append file ".bin") package))
                         files))))
-       (sf-and-load '("macros") '(EDWIN MACROS))
-       (sf-and-load '("clsmac") '(EDWIN CLASS-MACROS))
+       (sf-and-load '("macros") '(edwin macros))
+       (sf-and-load '("clsmac") '(edwin class-macros))
        (sf-and-load '("xform")
-                    '(EDWIN CLASS-MACROS TRANSFORM-INSTANCE-VARIABLES))
-       (sf-and-load '("class") '(EDWIN))
-       (sf-and-load '("clscon") '(EDWIN CLASS-CONSTRUCTOR)))))
+                    '(edwin class-macros transform-instance-variables))
+       (sf-and-load '("class") '(edwin))
+       (sf-and-load '("clscon") '(edwin class-constructor)))))
 
 (let ((read-class-definitions
        (lambda (filename)
@@ -65,13 +65,13 @@ USA.
                   (write filename port))
               (lambda ()
                 (syntax* (read-file (string-append filename ".scm"))
-                         (->environment '(EDWIN WINDOW)))))
+                         (->environment '(edwin window)))))
             (begin
               (fresh-line)
               (write-string "Pre-loading class definitions from ")
               (write filename)
               (syntax* (read-file (string-append filename ".scm"))
-                       (->environment '(EDWIN WINDOW)))
+                       (->environment '(edwin window)))
               (write-string " -- done")
               (newline))))))
   (read-class-definitions "window")
@@ -84,5 +84,5 @@ USA.
 
 (load "decls")
 
-(cref/generate-constructors "edwin" 'ALL)
+(cref/generate-constructors "edwin" 'all)
 (sf-conditionally "edwin.ldr")
\ No newline at end of file