home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / sprint / texmac.zip / GLOSS.SPM < prev    next >
Text File  |  1991-11-23  |  21KB  |  720 lines
  1. ; Copyright (c) 1988 Borland International.  All Rights Reserved
  2. ;
  3. ; NAME: GLOSS.SPM
  4. ; VERSION: 1.01
  5. ; DESCRIPTION: Glossary Macro Package for Sprint
  6. ; LAST UPDATE: September 9, 1988, 6/19/91 RDT to ensure HOME dir is used right
  7. ; ALWAYS make sure QA is handled to look in HOME dir if it exists
  8. ; I did this by modifying GlossQDName and trying to always use it
  9. ; instead of QA itself
  10. ;
  11. ; NOTES: This file must be compiled and loaded AFTER CORE.SPM any other macro
  12. ; packages.
  13. ; Should probably merge in all the macrocoll stuff from nother,
  14. ; since it's more logical and useful to only use macro recording under
  15. ; the auspices of Glossary
  16. ; 
  17. ; These macros use QB to hold a definition file, and QC to hold a string.
  18. ; The glossary function defaults to a glossary file called "standard.spg".
  19. ; The name is stored in QA.  When a new glossary name is chosen, its name
  20. ; is placed in QA.  It is the responsibility of the UI to insure that
  21. ; QA is initialized to the proper glossary name on Start-up.
  22. ; You should probably not use either one, or at least, if you use QC, set
  23. ; it to be empty when you're done.  (At the expense of speed, you can do the
  24. ; same to QB.)  If the glossary has been modified, you should really write
  25. ; it out (silently): "mark (to QB if modf (write QA))"
  26. ; when the user exits, without asking.  Alternatively, the write can be done
  27. ; (or done with query) each time the glossary is actually modified.  In order
  28. ; for this to work, the macros should not use QB for *anything* else, because
  29. ; a length-test is done to determine if the glossary file has been loaded.
  30. ;
  31. ; The glossary file has the following structure:
  32. ;    char. 255
  33. ;    Item name
  34. ;    char. 255
  35. ;    Hard newline (char. 10)
  36. ;    Item text
  37. ;    Hard newline
  38. ;
  39. ; The first character of the item text may be a '%'.  In that case, it is a
  40. ; flag to indicate that the item text is to be executed as a MACRO, rather than
  41. ; pasting the item text into the file.
  42. ; Macros may have an optional comment at the end, as usually, the comment is
  43. ; separated from the text of the macro by a semicolon. This comment will appear
  44. ; as a description of the macro when using GlossList.
  45. ; 
  46. ; An initial value of 254 for the expansion indicates it is a keyboard recording
  47. ; and should be pushed back.
  48. ; Keyboard recordings may have comments too, entered as a description when user
  49. ; ends the record. This description is separated from the the recording by 254
  50. ; character, and will appear in GlossList.
  51. ;
  52. ; Any other character as the first character in the item text is taken to be a 
  53. ; literal character to be inserted.
  54. ; As you can see, this means that strings in the glossary are not allowed to
  55. ; contain character numbers 255/254, or start with a '%'.  Names are restricted
  56. ; to be just tokens.
  57. ;
  58. ; These operations are available:
  59. ;
  60. ;    GlossChange        load new glossary file
  61. ;    GlossDefine1        add new item, ask for name, expansion in clipboard
  62. ;    GlossDefine2        add new item, name in QD, expansion in clipboard
  63. ;    GlossDefineKey        add recording in QF to glossary, ask for name
  64. ;    GlossInsertText    Insert glossary text from QC, reading ruler if present
  65. ;    GlossLookup1        expand item, find name in text
  66. ;    GlossLookup2        expand item, ask for name
  67. ;    GlossLookup3        expand item, name in QD
  68. ;    GlossLookup4        expand item, try from file, else prompt, ENTER = pick
  69. ;    GlossDelete        delete item, ask for name
  70. ;    GlossRename        rename item, ask for name, ask for new name
  71. ;    GlossMakeList        Display menu of items, return name in QC
  72. ;    GlossPickList        Display menu of items, expand picked item
  73. ;    GlossQDName        Take file name in QA, move to QD, prepending home dir
  74. ;    GlossList            list all items
  75. ;    GlossErase        erase all items
  76. ;    GlossSave            save all items if modified and length != 0
  77. ;    GlossWrite        always save all items
  78. ;    GlossEnsure        load all items
  79. ;
  80. ;----------------------------------------------
  81. ; Q register usage: see SP.SPM for table
  82. ;-------------------------------------------===
  83. ;    NUMBERED MARK USAGE:
  84. ;    see SP.SPM
  85. ;----------------------------------------------
  86. ;    CONTENTS:
  87. ;    SECTION:  Routines whose definitions are to be removed.
  88. ;    SECTION:    Routines that MUST exist for the compiler to work
  89. ;    SECTION:    Variables -- all the variables are declared here
  90. ;    SECTION:    Forward declarations -- In order to keep the main list
  91. ;            of macros in alphabetical order, a few of them have to be
  92. ;            declared ahead of time -- like a FORWARD declaration
  93. ;            in Pascal
  94. ;    SECTION:    Automatically-called macro definitions (Main, Init,
  95. ;            EditKeys, MacroKeys, etc.)
  96. ;    SECTION:    General and command macros in alphabetical order
  97. ;    SECTION:    Menus (leaves first, root last)
  98. ;    SECTION:    Control and function keys
  99. ; -----------------------------------------------------------------
  100. ; Deletions
  101.  
  102. ; -----------------------------------------------------------------
  103. ; Compiler-Required Definitions
  104.  
  105. ; -----------------------------------------------------------------
  106. ; Variables
  107.  
  108. int GlossType
  109.  
  110. ; -----------------------------------------------------------------
  111. ; Forward Declarations
  112.  
  113. GlossDefineRest :
  114. GlossDefineStart :
  115. GlossDeleteRest :
  116. GlossFound :
  117. GlossFoundMsg :
  118. GlossGetName :
  119. GlossInsertText :
  120. GlossLookupRest :
  121. GlossMakeList :
  122. GlossPickList :
  123. GlossPrep :
  124. GlossQDName :
  125. GlossSave :
  126. TimeDate :
  127.  
  128. ; -----------------------------------------------------------------
  129. ; Automatically-Called Macro Definitions
  130.  
  131. ; -----------------------------------------------------------------
  132. ; General Macros
  133.  
  134. ; Prompt for new glossary name, create one if name doesn't exist
  135.  
  136. GlossChange : ; RDT, changed
  137.     GlossSave    ; save any existing glossary
  138.     set QB ""    ; force a reread of new file
  139. ;    set QD ""
  140.     GlossQDName  ; put QA in QD and massage
  141.     message "\nGlossary to use: "    set QD  ; allow user to change QD/QA
  142.     if (!length QD) (set QD "*.spg")        ; to force a list if no entry
  143.     set QD fchange "%.SPG" QD
  144.     13 QCap
  145.     if !(2 exist QD) {
  146.         1 Bell
  147.         message "\nCould not find `"
  148.         message QD
  149.         if (ask "'.  Create it? ") {
  150.             set QB ""    ; clear out anything that was in swap file
  151.             open QD
  152.             if !stopped (write "%")
  153.             (set QA QD) else (message "\nIllegal glossary name")
  154.             close
  155.             }
  156.         }
  157.     else (set QA QD) ; result should be pathed .SPG file in QA
  158.  
  159. ; Get a name, and return T or F depending upon whether the name is in
  160. ; the glossary.
  161.  
  162. GlossCheckName :
  163.     GlossGetName
  164.     GlossFoundMsg
  165.  
  166.  
  167. ; Add a new name, asking the user for the name.  If a region is
  168. ; selected, add that text.  Otherwise, use what is in the clipboard.
  169.  
  170. GlossDefine1 :
  171.     GlossDefineStart
  172.     if (select = 1) {
  173.         copy togmark
  174.         Unselect
  175.         }
  176.     else if (select > 1)
  177.         (error "You cannot glossarize columns of text, only regions.")
  178.     message "\nEnter the name for this item: "
  179.     1->GlossType
  180.     GlossGetName
  181.     GlossDefineRest
  182.  
  183.  
  184. ; Add a new name.  The new name is in QD and the expansion is in the
  185. ; clipboard.
  186.  
  187. GlossDefine2 :
  188.     GlossDefineStart
  189.     set QC QD
  190.     1->GlossType
  191.     GlossDefineRest
  192.  
  193. ; Take the keyboard recording in QF and place it in the glossary.
  194. ; Ask for name, Check length of QF, give error if to long (> 1024 keys)
  195. ; Keyboard recording will be marked by having a first character byte value
  196. ; of 254 (feh).
  197.  
  198. GlossDefineKey :
  199.     if (length QF > 1024) error "Recording too long to play back."
  200.     else if (length QF==1) {    ; user canceled immediately
  201.         message "\nRecording Canceled."
  202.         return
  203.         }
  204.     GlossDefineStart                ; check exist QA, if recording was short enough...
  205.     message "\nEnter the name for this recording: "
  206.     GlossGetName
  207.     set QD "" message "\nDescription (Enter for none): "
  208.     set QD                        ; description in QD
  209.     mark {
  210.         to QF
  211.         254 insert                ; mark item as recording
  212.         toend 254 insert insert QD    ; add description
  213.         }
  214.     2->GlossType GlossDefineRest
  215.  
  216. ; Do the rest of the work for GlossDefine*
  217.  
  218. GlossDefineRest :
  219.     if GlossFound {
  220.         message "\nDo you want to replace the existing `"
  221.         message QC
  222.         if (ask "'? ") GlossDeleteRest
  223.         else return
  224.         }
  225.     mark {
  226.         to QB
  227.         f toend
  228.         insert QC                        ; name between 255's
  229.         '^J' insert                    ; new line
  230.         if (GlossType = 2) insert QF         ; keyboard recording: in QF
  231.         else undelete                    ; macro or text: in clipboard
  232.         '^J' insert                    ; new line
  233.         r (to current = 255) c            ; go to start of expansion text
  234.         mark {
  235.             while (255 csearch) del    ; sanitize the text to be glossarized
  236.             }
  237.         if current = '%' {            ; if a macro, remove all NL's and Tabs
  238.             while ('^J' csearch) (32 -> current)
  239.             r to (current = 255) while ('^I' csearch) (32->current)
  240.             }
  241.         }
  242.  
  243.  
  244. ; Set up for GlossDefine*
  245.  
  246. GlossDefineStart : ; RDT, changed
  247. ;    set Q0 "spedit.exe" NeedDisk
  248.     GlossQDName ; massage QA
  249.     if !(2 exist QD) {
  250.         1 Bell
  251.         message "\nCould not find `"
  252.         message QD
  253.         if (ask "'.  Create it? ") {
  254.             ; GlossQDName ; unnecessary now
  255.             open QD
  256.             write "%"
  257.             close
  258.             }
  259.         }
  260.  
  261. ; Ask for a name and delete the glossary entry.
  262.  
  263. GlossDelete :
  264.     message "\nGlossary item to delete (Enter for list): "
  265.     if GlossCheckName {
  266.         GlossDeleteRest
  267.         if (!length QB) {
  268.             mark {
  269.                 to QB
  270.                 GlossQDName 1 write QD
  271.                 }
  272.             }
  273.         draw
  274.         message "\nItem deleted."
  275.         }
  276.  
  277.  
  278. ; Delete the glossary entry contained in QC.  The entry is known to exist.
  279.  
  280. GlossDeleteRest :
  281.     mark {
  282.         to QB
  283.         1 search QC
  284.         mark {
  285.             toeol
  286.             255 csearch
  287.             erase tomark
  288.             }
  289.         }
  290.  
  291.  
  292. ; Make sure that the glossary is loaded.  If not, error out.  Note
  293. ; that a zero-length glossary file will always be reread.
  294.  
  295. GlossEnsure : ; RDT, changed
  296. ;    set Q0 "spedit.exe" NeedDisk
  297.     GlossQDName  ; put QA in QD and massage
  298.     mark {
  299.         to QB
  300.         if (!length && !(2 read QD))
  301.             (error "Glossary file not found.")
  302.         }
  303.  
  304.  
  305. ; Erase the glossary.
  306.  
  307. GlossErase : ; remove gloss file 
  308.     GlossEnsure
  309.     set QB ""
  310.     mark (to QB 0->modf)
  311.     GlossQDName
  312.     fdelete QD
  313.  
  314.  
  315. ; Prepare the name in QC and check whether it exists.  Return T/F
  316.  
  317. GlossFound :
  318.     12 GlossPrep
  319.     GlossEnsure
  320.     mark (to QC while !isend ToLower)    ; convert name to lowercase
  321.     mark {
  322.         to QB
  323.         if (1 search QC) 1
  324.         else 0
  325.         }
  326.  
  327.  
  328. ; Prepare the name in QC and check whether it exists.  Return T/F and
  329. ; print a message if it doesn't.
  330.  
  331. GlossFoundMsg :
  332.     if !GlossFound {
  333.         message "\nNo glossary entry for `"
  334.         message QC
  335.         message "'."
  336.         1 Bell
  337.         0
  338.         }
  339.     else    1
  340.  
  341.  
  342. ; Ask the user for a name of an item and make sure that it is a legal
  343. ; name.
  344.  
  345. GlossGetName :
  346.     set QC ""
  347.     set QC                        ; get the name
  348.     mark {
  349.         to QC                    ; make sure it's a simple name
  350.         while ((f past istoken) && !isend) {
  351.             if stopped {
  352.                 message "\nThat name is invalid.  Please enter another: "
  353.                 set QC ; hope this always works (setting itself inside qswitch!)
  354.                 r toend
  355.                 } abort
  356.             }
  357.         }
  358.     if !length QC {                ; if QC empty get name from list
  359.         if stopped{
  360.             GlossMakeList            ; force a name into QC
  361.             } abort
  362.         }
  363.  
  364.  
  365. ; Insert Glossary expansion.  If it contained a ruler, read it.
  366.  
  367. GlossInsertText :
  368.     insert QC
  369.     mark(to QC '^K' csearch) ? (readruler refill)
  370.  
  371. ; List all the glossary items.  This is going to be put into a fixed
  372. ; file name in a buffer.  We use QC for intermediate storage of the
  373. ; list because of the problem of getting back to where we were in QB
  374. ; if we were to switch into the file to copy the name each time.
  375.  
  376. GlossList :
  377.     GlossEnsure
  378.     status "\nBuilding glossary list..."
  379.     0->append
  380.     set Q0 fchange "%.SPR" QA                    ; under name
  381.     if 0 QWild 10 set Q0 flist Q0
  382.     if (buffind Q0 || open Q0) clear                ; erase if needed
  383. ;    70->rightmargin 0->indent 15->leftmargin insertruler    ; ensure proper alignment
  384.     insert "List for " insert QA insert " as of " TimeDate
  385.     insert "^J^JDefined Glossary Items^J"
  386.     insert "----------------------^J"
  387.     mark {
  388.             to QB
  389.             while (255 csearch) {                ; find entry name
  390.             c copy (to (current = 255)) QC        ; copy name in QC
  391.             toeol c                            ; to entry on next line
  392.             copy (to (current = 255) r c) QD        ; put entry in QD
  393.             mark {to QD                        ; look at entry
  394.                 if (current = '%') {            ; this is a Sprint Macro
  395.                     erase (to current =';')        ; look for comment
  396.                     del erase past iswhite        ; go to text of comment
  397.                     insert "MACRO: "        }            ; insert glossary type
  398.                 if (current = 254)            {    ; this is a record
  399.                     del erase to (current = 254)
  400.                     del insert "RECORDING: " }
  401.                 if (current = '^K') {            ; this is a ruler line
  402.                     del
  403.                     insert "RULER: "
  404.                     toeol c r del
  405.                             }
  406.                 else (r c)                    ; normal text
  407.                 if (to isnl) (erase toend insert "...")    ; too long...
  408.                 buffind Q0 toend insert QC        ; entry name
  409.                 tosol ToUpper toeol                ; Names in init caps
  410.                 '^I' insert insert QD '^J' insert    ; tab and expansion
  411.                 }
  412.                                 }
  413.         }
  414. ;    0->modf                            ; allow quitting with no prompt
  415.     r toend                            ; Top of file.
  416.  
  417.  
  418. ; Pull word out from text, Return True if found, false if no entry
  419.  
  420. GlossLookupStart :
  421.     int GlossTmp
  422.     mark {
  423.         if isgray (r past iswhite)        ; if between words, do prev
  424.         r past istoken
  425.         if inruler {
  426.             set QC ""
  427.             0->GlossTmp
  428.             }
  429.         else mark {
  430.             past istoken
  431.             copy tomark QC                    ; get the word
  432.             GlossFound->GlossTmp
  433.             if GlossTmp (erase tomark)
  434.             }
  435.         }
  436.     GlossTmp
  437.  
  438. ; #1: Find the word just before the cursor, or the word
  439. ; that the cursor is in, and replace it with the glossary entry.
  440.  
  441. GlossLookup1 :
  442.     if GlossLookupStart GlossLookupRest
  443.     else {
  444.         if !length QC message "\nEntry not defined."
  445.         else {
  446.             message "\nNo glossary entry for `"
  447.             message QC
  448.             message "'."
  449.             }
  450.         1 Bell
  451.         }
  452.  
  453.  
  454. ; #2: Ask the user for the name and insert the expansion.
  455.  
  456. GlossLookup2 :
  457.     message "\nGlossary item to insert (Enter for list): "
  458.     if GlossCheckName GlossLookupRest
  459.  
  460.  
  461. ; #3: Use the name in QD and insert name and insert the expansion.
  462.  
  463. GlossLookup3 :
  464.     set QC QD
  465.     if GlossFoundMsg GlossLookupRest
  466.  
  467.  
  468. ; #4: Try #1, if not found, prompt, if user presses [ENTER] give list
  469.  
  470. GlossLookup4 :
  471.     if record (stopped error "Glossary not available while recording" return)
  472.     if GlossLookupStart GlossLookupRest    ;try to expand from file
  473.     else    {                            ; could not expand from file, so ask user
  474. ;        message "\nGlossary item (Enter for list): "
  475. ;        GlossGetName 
  476.         GlossMakeList    ; skip the user input and draw the list
  477.         if GlossFoundMsg GlossLookupRest
  478.         }
  479.  
  480. ; used by GlossLookup*.  This routine locates and inserts the expansion.
  481. ; if it's a macro, it executes it.
  482.  
  483. GlossLookupRest :
  484.     mark {
  485.         to QB                    ; contains the glossary
  486.         1 search QC                ; the name is known to exist
  487.         toeol                    ; end of line name is on
  488.         f c                        ; next line: expansion
  489.         mark {
  490.             255 csearch            ; find end of expansion
  491.             r c                    ; don't take 255
  492.             0->append                ; don't add to QC (just in case)
  493.             copy tomark QC            ; copy expansion to QC
  494.             }
  495.         }
  496.     mark {
  497.         to QC                    ; process this expansion
  498.         current case {
  499.             '%' del 1->GlossType,    ; check if macro, and delete leading '%'
  500.             254 del 2->GlossType    ; keyboard recording
  501.                 if (254 csearch) (erase toend),    ; get rid of description
  502.             $   0->GlossType        ; plain text
  503.             }
  504.         }
  505.     GlossType case {                ; case must do stuff outside of QC
  506.         1 if ((length QC) < 512) {
  507.             set QG QC    ; put it in Q for MacroExecute again, I spose this is dumb
  508.             macro QC
  509.             }
  510.           else error "Macro too long",        ; execute the macro
  511.         2 mark(to QC copy toend QF) keypushback QC,        ; push back the keyboard recording, and place into QF too for macro iterate, RDT
  512.         $ GlossInsertText            ; insert text
  513.         }
  514.  
  515.  
  516. ; Display menu, return the chosen name in QC
  517.  
  518. GlossMakeList :
  519.     GlossEnsure                    ; force load of glossary
  520.     if !(length QB) (error "No entries are defined")
  521.     0->append
  522.     set QC ""                        ; clear QC to receive list
  523.     mark {
  524.         to QB
  525.         while (255 csearch) {        ; find entries
  526.             c                    ; jump 255
  527.             copy (to (current = 255)) QD    ; copy entry in scratch Qreg
  528.             mark (to QC toend            ; go to end of QC in imenu format:
  529.             insert "^I\"" 
  530.             insert QD insert "\",^J")    ; tab, entry between quotes,
  531.             toeol c                ; to return value, comma new line
  532.             to current = 255        ; skip expansion
  533.             }
  534.         to QC
  535.         insert "imenu \"Glossary Items\" {"    ; build menu
  536.         toend r (del del) insert "$}"        ; delete last new line and comma
  537.         }
  538.     if ((length QC) < 1024) {
  539.         status "\n"
  540.         macro QC                        ; display menu to choose from
  541.         set QC Q0                        ; glossary to expand in QC
  542.         }
  543.     else error "Too many entries for menu"
  544.  
  545. ; Merge two glossary files together.
  546. ; QA contains name of glossary to add items to.
  547. ; system will prompt for name of glossary to add to it.
  548.  
  549. GlossMerge : ; RDT, changed
  550.     GlossEnsure
  551.     set QD home  ;"" ; put home in to suggest correct location
  552.     mark { to QD toend insert "*.SPG" } ; append extension
  553.     message "\nGlossary to merge with '" QA "': " ; current gloss
  554.     set QD
  555.     if (!length QD) (set QD "*.spg")        ; to force a list if no entry
  556.     set QD fchange "%.SPG" QD        ; name is in QD
  557.     if !(2 exist QD) {
  558.         stopped error "Glossary file not found"
  559.         return
  560.         }
  561.     if stopped {
  562.         2 open QD    draw            ; open glossary to be merged
  563.         while (255 csearch) {
  564.             c    ; skip the 255
  565.             copy (to current = 255) QC    ; name in QC
  566.             while GlossFound {    ; item was found so allow user to decide outcome
  567.                 set Q0 QC
  568.                 mark(to Q0 del insert "DUPLICATE ITEM: " toend r del)
  569.                 menu  Q0  {
  570.                     "Replace existing definition"    0,
  571.                     "Add under new name"    1,
  572.                     "Don't merge (skip)"    2
  573.                 }
  574.                 case {
  575.                     0 GlossDeleteRest,    ; erase existing definition
  576.                     1 message "\nNew name for " QC ": " GlossGetName,    ; get a new name
  577.                     2 set QC "" break
  578.                     }
  579.                 } ; end while
  580.             toeol c
  581.             if length QC {        ; if we are adding a definition
  582.                 copy (to current = 255 r c )    ; leave off end of record
  583.                 GlossDefineRest    ; name in QC, expansion in kills buffer
  584.                 }
  585.             }
  586.         close        ; put away glossary
  587.         }
  588.     close
  589.  
  590. GlossPickList :    ; display a menu, let user pick from it
  591.     status "\nBuilding glossary menu..."
  592.     GlossMakeList
  593.     GlossLookupRest
  594.  
  595. ; Prepare the name by inserting 255s.  The argument is the Q register
  596. ; number.
  597.  
  598. GlossPrep :
  599.     mark {
  600.         qswitch
  601.         if current != 255 {        ; if not prepared already....
  602.             255 insert
  603.             f toend
  604.             255 insert
  605.             }
  606.         }
  607.  
  608. ; Make path name for Glossary file name in QD
  609. GlossQDName :
  610.     set QD QA ; get stored gloss file name in scratch QD
  611.     set Q0 home ; put home into Q0 for test and massage
  612.     0 QCap ; cap home
  613.     if (length Q0) { ; if there's a home env. var. massage QD
  614.         mark { to Q0 ; go into Q0
  615.             if !(3 search "[/\\\\:]") { ; if there're no slashes or it's not a drive
  616.                 toend insert '\\' }  ; put in a slash at the right end
  617.              }; end Q0 mark
  618.         mark { to QD ; Now go into the QD register
  619.             if !(3 search "[/\\\\:]") { ; if there're no slashes in QA/QD, it's not a pathed name
  620.                 r toend  ; get in front of QA
  621.                 insert Q0 ; which should be empty or contain HOME Env var
  622.                         ; if empty, current dir. is default
  623.                 }
  624.             } ; end QD mark 
  625.     } ; result of all this should be QD containing massaged version of QA, the current gloss file name
  626.  
  627. ; Rename an existing glossary item.  Ask the user for an item name,
  628. ; make sure that it exists, ask for another name, and make sure that it
  629. ; *doesn't* exist, and then do the rename operation.
  630.  
  631. GlossRename :
  632.     message "\nGlossary item to be renamed (Enter for list): "
  633.     if !GlossCheckName return
  634.     set QD QC        ; save the first name; we'll need it again
  635.     message "\nRename '"
  636.     message QD
  637.     message "' to be: "
  638.     GlossGetName
  639.     if GlossFound {
  640.         message "\nThe new name `"
  641.         message QC
  642.         message "' already exists."
  643.         1 Bell
  644.         return
  645.         }
  646.     else    {
  647.         mark {
  648.             to QB
  649.             1 search QD
  650.             replace found QC
  651.             }
  652.         message "\nItem renamed."
  653.         }
  654.  
  655. ; Save the glossary if it is modified and has a nonzero length.
  656. GlossSave :
  657.     mark {
  658.         to QB
  659.         if (length && modf) {
  660.             message "\nSave changes to glossary file '" QA "'"
  661.             if ask "(Y,N,ESC)?" {
  662. ;                set Q0 "spedit.exe" NeedDisk
  663.                 GlossQDName 1 write QD
  664.                 }
  665.             }
  666.         }
  667.  
  668. ; Always write the glossary.
  669.  
  670. GlossWrite : 
  671. ;    set Q0 "spedit.exe" NeedDisk
  672.     GlossQDName
  673.     mark (to QB write QD)
  674.  
  675. ; -----------------------------------------------------------------
  676. ; Menus
  677.  
  678. ;GlossMenu :
  679. ;    menu "Glossary" {
  680. ;    "Expand item from file"    GlossLookup1,
  681. ;    "Insert item by name"    GlossLookup2,
  682. ;    "Pick item from menu"    GlossPickList,
  683. ;    "Define item"            GlossDefine1,
  684. ;    "Rename item"            GlossRename,
  685. ;    "List items"            GlossList,
  686. ;    "delete item"            GlossDelete,
  687. ;    "Save glossary file"    GlossSave
  688. ;        }
  689.  
  690. KeyAssignGloss : 
  691.     do    {
  692.         status "\nTo which key should the glossary item be assigned: "
  693.         KeyGet->x if (x = '^[') abort
  694.         if (x KeyCanAssign) {
  695.             status "\nBuilding glossary menu"
  696.             GlossMakeList    ; get the name in QC
  697.             set QD ""
  698.             mark {
  699.                 to QD    ; build assign command in QD
  700.                 "set QD \""
  701.                 insert QC    ; name
  702.                 insert "\" glosslookup3"
  703.                 }
  704.             x macro QD    ; and bind it.
  705.             break
  706.             }
  707.         else KeyAssignError
  708.         }
  709.  
  710. KeyRecordEnd :        ; end keyboard recording and insert keys in Glossary
  711.     if record { MacroCollEnd
  712.         GlossDefineKey 
  713.         }    ; see keyrecordgloss
  714.  
  715. KeyRecordGloss :    ; Start recording keys for glossary
  716.     mode "Keyboard recording on. Use Alt-) to end recording."
  717.     MacroCollBegin
  718.  
  719. F1A9H : KeyRecordEnd ; Alt-)
  720.