PageRenderTime 79ms CodeModel.GetById 36ms RepoModel.GetById 0ms app.codeStats 1ms

/nmcobol-mode.el

https://github.com/emacsmirror/nmcobol-mode
Emacs Lisp | 2162 lines | 1677 code | 166 blank | 319 comment | 78 complexity | 794f099dbe49df543a16b2714595bad2 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. ;;; nmcobol-mode.el --- For use with Tandem Cobol only - Sorry.
    2. 

  2. 

  3. ;; Copyright (C) 2006, 2007 Free Software Foundation, Inc.
    4. 

  4. 

  5. ;; Author: Rick Bielawski <rbielaws@i1.net>
    6. 

  6. ;; Keywords: languages, COBOL, Tandem, Guardian, NSK
    7. 

  7. ;; Maintainer: Rick Bielawski <rbielaws@i1.net>
    8. 

  8. 

  9. ;; This file is free software; you can redistribute it and/or modify
    10. 

  10. ;; it under the terms of the GNU General Public License as published by
    11. 

  11. ;; the Free Software Foundation; either version 2, or (at your option)
    12. 

  12. ;; any later version.
    13. 

  13. 

  14. ;; This file is distributed in the hope that it will be useful,
    15. 

  15. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
    16. 

  16. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    17. 

  17. ;; GNU General Public License for more details.
    18. 

  18. 

  19. ;; You should have received a copy of the GNU General Public License
    20. 

  20. ;; along with GNU Emacs; see the file COPYING.  If not, write to the
    21. 

  21. ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    22. 

  22. ;; Boston, MA 02110-1301, USA.
    23. 

  23. 

  24. ;;; Commentary:
    25. 

  25. 

  26. ;; NMCOBOL -- COmmon Business Oriented Language - in ?TANDEM line format.
    27. 

  27. 

  28. ;; This is currently a work-in-progress.  You are welcome to try it and
    29. 

  29. ;; submit changes or report bugs but there is no point trying to report
    30. 

  30. ;; lack of features unless you are including patches that address such
    31. 

  31. ;; shortcomings.
    32. 

  32. ;;
    33. 

  33. ;; Since Tandem's line format is not standard this mode is not likely to
    34. 

  34. ;; suit the needs of most Cobol progammers.  Moreover, Tandem Cobol has
    35. 

  35. ;; extensions that standard Cobol doesn't have and may not implement
    36. 

  36. ;; features required or generally available by other Cobol compilers.
    37. 

  37. ;; I'm happy to add submitted patches to support other compilers only if
    38. 

  38. ;; such patches don't interfere with support of Tandem Cobol.
    39. 

    40. 

  40. ;;; Installing:
    41. 

  41. 

  42. ;; Before you can use nmcobol-mode, emacs needs to be able to find it.  Place
    43. 

  43. ;; the nmcobol-mode.el file in a directory on the load-path; typically the
    44. 

  44. ;; .../site-lisp or perhaps .../lisp/progmods directory.  Usually you would
    45. 

  45. ;; also want to byte compile nmcobol-mode.el but this is not required.  To do
    46. 

  46. ;; this, visit the nmcobol-mode.el file, type: M-x emacs-lisp-byte-compile <ret>
    47. 

  47. ;; There should be no warnings or errors during byte compilation.
    48. 

  48. ;;
    49. 

  49. ;; There are 4 basic ways to use NMCOBOL-MODE on a file.  The first method
    50. 

  50. ;; manually selects nmcobol-mode as the editing mode.  The other 3 cause emacs
    51. 

  51. ;; to recognize automatically that you want to visit the file using
    52. 

  52. ;; nmcobol-mode.
    53. 

  53. ;;
    54. 

  54. ;; Pick one:
    55. 

  55. ;; 1. While visiting a file, type: M-x nmcobol-mode <ret>
    56. 

  56. ;; 2. Put the string -*-nmcobol-*- in a comment on the first line of the file.
    57. 

  57. ;;    Save the file and close it.  Now any time you open it nmcobol-mode starts.
    58. 

  58. ;; 3. Create an association between a particular file naming convention and
    59. 

  59. ;;    nmcobol-mode.  This is done by adding an association to auto-mode-alist.
    60. 

  60. ;; For example:
    61. 

  61. ;; (setq auto-mode-alist
    62. 

  62. ;;   (append
    63. 

  63. ;;     '(("\\.cob\\'" . nmcobol-mode)      ;extension of .cob means nmcobol-mode
    64. 

  64. ;;       ("\\([\\/]\\|^\\)[^.]+$" . nmcobol-mode)) ;so does no extension at all.
    65. 

  65. ;;    auto-mode-alist))
    66. 

  66. ;; 4. Advise set-auto-mode to look at the buffer contents upon loading.
    67. 

  67. ;;    For an example see: http://www.emacswiki.org/cgi-bin/wiki/TandemNskSupport
    68. 

  68. ;;
    69. 

  69. ;; The above all tell emacs that you want to use nmcobol-mode but you must load
    70. 

  70. ;; nmcobol-mode before you can use it.  There are 2 methods of telling emacs to
    71. 

  71. ;; load the nmcobol-mode routines.  The first unconditionally loads nmcobol-mode
    72. 

  72. ;; definitions immediately.  The second tells emacs to automatically load
    73. 

  73. ;; nmcobol-mode only when you try to use it.  Add one of the following lines to
    74. 

  74. ;; your .emacs file.
    75. 

  75. ;;
    76. 

  76. ;;(require 'nmcobol-mode)      ; Unconditional load
    77. 

  77. ;;(autoload 'nmcobol-mode "nmcobol-mode" "Major mode for Tandem NMCOBOL files." t nil)
    78. 

  78. ;;
    79. 

  79. ;;; Getting eldoc to work in nmcobol-mode:
    80. 

  80. 

  81. ;; Open a file containing variable declarations for which you want
    82. 

  82. ;; help permanently loaded.  For example: $SYSTEM.COPYLIBS.COBOLLIB.
    83. 

  83. ;; The buffer must be in nmcobol-mode or ddl-mode.
    84. 

  84. ;; Use:  M-x nmcobol-mode <ret> if necessary.
    85. 

  85. ;; Then: M-x nmcobol-eldoc-make-list <ret>
    86. 

  86. ;; You should now be in a specially formatted buffer containing a list of
    87. 

  87. ;; the variables declared and their corresponding help strings.  You can
    88. 

  88. ;; modify the strings themselves if desired but do not alter anything
    89. 

  89. ;; else.  Repeat these steps to add more help entries to the file.
    90. 

  90. ;; Save the file somewhere on your search list like your site-lisp
    91. 

  91. ;; directory. Example:
    92. 

  92. ;;     C-x C-w ~/../site-lisp/extdecs-help.el <ret>
    93. 

  93. ;; Now add the file you just saved to the list of nmcobol-mode eldoc help
    94. 

  94. ;; files to be loaded.
    95. 

  95. ;;     M-x customize-option <ret> nmcobol-eldoc-def-files <ret>
    96. 

  96. ;; Save the customization for future sessions.
    97. 

  97. ;; Once you have your help entries defined see help for eldoc-mode for
    98. 

  98. ;; turing on the mode.  Putting (eldoc-mode t) in .emacs might do it.
    99. 

  99. 

  100. ;;; History:
    101. 

  101. 

  102. ;; 2006-11-07 RGB Started writing this mode using my cobol-mode as skeleton.
    103. 

  103. ;; 2006-12-18 RGB Added eldoc support.
    104. 

  104. ;; 2006-12-26 RGB Added nmcobol-addup-pics.
    105. 

  105. ;; 2006-12-27 RGB Added thing-at-point support for Guardian style 'filename.
    106. 

  106. ;; 2006-12-29 RGB Added an NMCobol menu and nmcobol-customize-options.
    107. 

  107. ;; 2007-01-03 RGB Added movement by sentences.
    108. 

  108. ;; 2007-01-04 RGB Fixed movement by sentences, added paragraphs.
    109. 

  109. ;; 2007-01-04 RGB Make COUNT argument in movement by functions optional.
    110. 

  110. ;; 2007-01-09 RGB Added eldoc for variables including a buffer-local obarray.
    111. 

  111. ;; 2007-01-10 RGB Added Cobol specific support for anchored-transpose.
    112. 

  112. ;; 2007-01-11 RGB Fixed 66 level handling in paragraph movement and eldoc-scan.
    113. 

  113. ;; 2007-01-28 RGB Sentence/Paragraph movement now saves match data.
    114. 

  114. ;; 2007-01-31 RGB Started adding automatic indentation.
    115. 

  115. ;; 2007-02-01 RGB Made * electric.
    116. 

  116. ;; 2007-02-05 RGB Auto-indent now operates on regions
    117. 

  117. ;; 2007-02-07 RGB Fixed customization of nmcobol-keywords-case &
    118. 

  118. ;;                nmcobol-imenu-menubar. Fixed nmcobol-pic-string-regexp
    119. 

  119. ;;                not recognizing 'ZZZ-.' syntax.  Fixed
    120. 

  120. ;;                nmcobol-char-maybe-comment which broke numeric
    121. 

  121. ;;                prefix behavior.  Doc-string updates.
    122. 

  122. ;; 2007-02-12 RGB Indentation now handles all the block statements properly.
    123. 

  123. ;; 2007-02-13 RGB The beginning of secondary indentation started.  This
    124. 

  124. ;;                handles alignment of things like picture clauses, TO
    125. 

  125. ;;                statements etc.
    126. 

  126. ;; 2007-02-19 RGB imenu now ignores xxxx-exit paragraphs.  Started trying
    127. 

  127. ;;                to implement paren matching on end-<verb> keywords.
    128. 

  128. ;; 2007-02-22 RGB nmcobol-get-block-type now ignores keywords in strings.
    129. 

  129. ;;; Code:
    130. 

  130. 

  131. (defgroup nmcobol nil
    132. 

  132.   "Major mode for editing NMCOBOL source files in Emacs.
    133. 

  133. While in nmcobol-mode use C-h m for a description of the mode's features."
    134. 

  134.   :prefix 'nmcobol-
    135. 

  135.   :group 'languages)
    136. 

    137. 

  137. ;;; SYNTAX TABLE
    138. 

  138. 

  139. (defvar nmcobol-mode-syntax-table
    140. 

  140.   (let ((st (make-syntax-table)))
    141. 

  141.     (modify-syntax-entry ?\n " " st)
    142. 

  142.     (modify-syntax-entry ?\! "." st)
    143. 

  143.     (modify-syntax-entry ?\" "." st)  ; wiki ?" bug workaround comment
    144. 

  144.     (modify-syntax-entry ?\# "w" st)
    145. 

  145.     (modify-syntax-entry ?\$ "w" st)
    146. 

  146.     (modify-syntax-entry ?\% "'" st)
    147. 

  147.     (modify-syntax-entry ?\& "'" st)
    148. 

  148.     (modify-syntax-entry ?\' "." st)
    149. 

  149.     (modify-syntax-entry ?\( "()" st)
    150. 

  150.     (modify-syntax-entry ?\) ")(" st)
    151. 

  151.     (modify-syntax-entry ?\* "." st)
    152. 

  152.     (modify-syntax-entry ?\+ "." st)
    153. 

  153.     (modify-syntax-entry ?\, "." st)
    154. 

  154.     (modify-syntax-entry ?\- "w" st)
    155. 

  155.     (modify-syntax-entry ?\. "." st)
    156. 

  156.     (modify-syntax-entry ?\/ "." st)
    157. 

  157.     (modify-syntax-entry ?\: "." st)
    158. 

  158.     (modify-syntax-entry ?\; "." st)
    159. 

  159.     (modify-syntax-entry ?\< "." st)
    160. 

  160.     (modify-syntax-entry ?\= "." st)
    161. 

  161.     (modify-syntax-entry ?\> "." st)
    162. 

  162.     (modify-syntax-entry ?\? "." st)
    163. 

  163.     (modify-syntax-entry ?\@ "." st)
    164. 

  164.     (modify-syntax-entry ?\[ "(]" st)
    165. 

  165.     (modify-syntax-entry ?\\ "." st)
    166. 

  166.     (modify-syntax-entry ?\] ")[" st)
    167. 

  167.     (modify-syntax-entry ?^  "w" st)
    168. 

  168.     (modify-syntax-entry ?\_ "w" st)
    169. 

  169.     (modify-syntax-entry ?\{ "(}" st)
    170. 

  170.     (modify-syntax-entry ?\| "." st)
    171. 

  171.     (modify-syntax-entry ?\} "){" st)
    172. 

  172.     st)
    173. 

  173.   "Syntax table for `nmcobol-mode'.")
    174. 

  174. 

  175. ;;; KEY MAP
    176. 

  176. 

  177. (defvar nmcobol-skeleton-map
    178. 

  178.   (let ((map (make-sparse-keymap)))
    179. 

  179.     (define-key map [?i]   'nmcobol-if-skel)
    180. 

  180.     (define-key map [?p]   'nmcobol-paragraph-skel)
    181. 

  181.     map)
    182. 

  182.   "Keymap for `nmcobol-mode'.")
    183. 

  183. 

  184. (defvar nmcobol-eldoc-map
    185. 

  185.   (let ((map (make-sparse-keymap)))
    186. 

  186.     (define-key map [?m]   'nmcobol-eldoc-make-list)
    187. 

  187.     (define-key map [?s]   'nmcobol-eldoc-scan-buffer)
    188. 

  188.     (define-key map [?v]   'nmcobol-eldoc-visit-file)
    189. 

  189.     (define-key map [?w]   'nmcobol-eldoc-where-def)
    190. 

  190.     map)
    191. 

  191.   "Keymap for `nmcobol-mode'.")
    192. 

  192. 

  193. (defvar nmcobol-mode-map
    194. 

  194.   (let ((map (make-sparse-keymap)))
    195. 

  195.     (define-key map [tab]             'indent-according-to-mode)
    196. 

  196.     (define-key map [?\C-c ?\C-c]     'column-marker-here)
    197. 

  197.     (define-key map [?\C-c ?\C-e]      nmcobol-eldoc-map)
    198. 

  198.     (define-key map [?\C-c ?\C-f]     'auto-fill-mode)
    199. 

  199.     (define-key map [?\C-c ?\C-o]     'nmcobol-customize-options)
    200. 

  200.     (define-key map [?\C-c ?\C-r]     'popup-ruler)
    201. 

  201.     (define-key map [?\C-c ?\C-s]      nmcobol-skeleton-map)
    202. 

  202.     (define-key map [?\C-c ?=]        'nmcobol-addup-pics)
    203. 

  203.     (define-key map [?\C-c return]    'comment-indent-new-line)
    204. 

  204.     (define-key map [?*]              'nmcobol-char-maybe-comment)
    205. 

  205.     (define-key map [?/]              'nmcobol-char-maybe-comment)
    206. 

  206.     map)
    207. 

  207.   "Keymap for `nmcobol-mode'.")
    208. 

  208. 

  209. (defun nmcobol-setup-menu ()
    210. 

  210.   "Adds a menu of NMCOBOL specific functions to the menu bar."
    211. 

  211.   (define-key (current-local-map) [menu-bar nmcobol-menu]
    212. 

  212.     (cons "NMCobol" (make-sparse-keymap "NMCobol")))
    213. 

  213.   (define-key (current-local-map) [menu-bar nmcobol-menu customize]
    214. 

  214.     '(menu-item "Customize" nmcobol-customize-options
    215. 

  215.                 :key-sequence [?\C-c ?\C-o]
    216. 

  216.                 :help "Customize nmcobol-mode options"))
    217. 

  217.   (define-key (current-local-map) [menu-bar nmcobol-menu comment-eol]
    218. 

  218.     '(menu-item "Comment EOL" comment-indent-new-line
    219. 

  219.                 :key-sequence [?\C-c return]
    220. 

  220.                 :help "Continues comment on new line"))
    221. 

  221.   (if (featurep 'column-marker)
    222. 

  222.       (define-key (current-local-map) [menu-bar nmcobol-menu column]
    223. 

  223.         '(menu-item "Column Marker" column-marker-here
    224. 

  224.                     :key-sequence [?\C-c ?\C-c]
    225. 

  225.                     :help "Puts column marker at current column (C-u removes)")))
    226. 

  226.   (define-key (current-local-map) [menu-bar nmcobol-menu ruler]
    227. 

  227.     '(menu-item "Ruler" popup-ruler
    228. 

  228.                 :key-sequence [?\C-c ?\C-r]
    229. 

  229.                 :help "Inserts temporary ruler"))
    230. 

  230.   (define-key (current-local-map) [menu-bar nmcobol-menu eldoc-show]
    231. 

  231.     '(menu-item "Eldoc Where" nmcobol-eldoc-where-def
    232. 

  232.                 :key-sequence [?\C-c ?\C-e ?w]
    233. 

  233.                 :help "Shows Where function at point is defined"))
    234. 

  234.   (define-key (current-local-map) [menu-bar nmcobol-menu eldoc-visit]
    235. 

  235.     '(menu-item "Eldoc Visit" nmcobol-eldoc-visit-file
    236. 

  236.                 :key-sequence [?\C-c ?\C-e ?v]
    237. 

  237.                 :help "Visits file defining function at point"))
    238. 

  238.   (define-key (current-local-map) [menu-bar nmcobol-menu eldoc-update]
    239. 

  239.     '(menu-item "Eldoc Scan" nmcobol-eldoc-scan-buffer
    240. 

  240.                 :key-sequence [?\C-c ?\C-e ?s]
    241. 

  241.                 :help "Updates buffer-local eldoc entries (in memory)"))
    242. 

  242.   (define-key (current-local-map) [menu-bar nmcobol-menu eldoc-create]
    243. 

  243.     '(menu-item "Eldoc Make List" nmcobol-eldoc-make-list
    244. 

  244.                 :key-sequence [?\C-c ?\C-e ?m]
    245. 

  245.                 :help "Puts current file eldoc entries in a file."))
    246. 

  246.   (define-key (current-local-map) [menu-bar nmcobol-menu skeletons]
    247. 

  247.     (cons "Skeletons" (make-sparse-keymap "Skeletons")))
    248. 

  248.   (define-key (current-local-map) [menu-bar nmcobol-menu skeletons if]
    249. 

  249.     '(menu-item "If Then" nmcobol-if-skel
    250. 

  250.                 :key-sequence [?\C-c ?\C-s ?i]
    251. 

  251.                 :help "Inserts an If/Then statement"))
    252. 

  252.   (define-key (current-local-map) [menu-bar nmcobol-menu skeletons paragraph]
    253. 

  253.     '(menu-item "New Paragraph" nmcobol-paragraph-skel
    254. 

  254.                 :key-sequence [?\C-c ?\C-s ?p]
    255. 

  255.                 :help "Inserts comment bars for new paragraph name")))
    256. 

  256. 

  257. ;; All keyword lists get sorted so new words can be anywhere within the
    258. 

  258. ;; appropriate list.  The keywords are currently only used for highlighting but
    259. 

  259. ;; more uses such as abbrev-mode are in progress.
    260. 

  260. 

  261. (defvar nmcobol-keywords-directives     ;font-lock-preprocessor-face
    262. 

  262.   '( "ANSI"            "BLANK"           "CALL-SHARED"     "CANCEL"
    263. 

  263.      "CHECK"           "CODE"            "COLUMNS"         "COMPACT"
    264. 

  264.      "COMPILE"         "CONSULT"         "CROSSREF"        "DIAGNOSE-74"
    265. 

  265.      "DIAGNOSE-85"     "DIAGNOSEALL"     "ENDIF"           "ENDUNIT"
    266. 

  266.      "ENV"             "ERRORFILE"       "ERRORS"          "FIPS"
    267. 

  267.      "FMAP"            "HEADING"         "HEAP"            "HIGHPIN"
    268. 

  268.      "HIGHREQUESTERS"  "ICODE"           "IF"              "IFNOT"
    269. 

  269.      "INNERLIST"       "INSPECT"         "LARGEDATA"       "LD"
    270. 

  270.      "LESS-CODE"       "LIBRARY"         "LINES"           "LIST"
    271. 

  271.      "LMAP"            "MAIN"            "MAP"             "NLD"
    272. 

  272.      "NOBLANK"         "NOCANCEL"        "NOCODE"          "NOCOMPACT"
    273. 

  273.      "NOCONSULT"       "NOCROSSREF"      "NODIAGNOSE-74"   "NODIAGNOSE-85"
    274. 

  274.      "NODIAGNOSEALL"   "NOFIPS"          "NOICODE"         "NOINNERLIST"
    275. 

  275.      "NOINSPECT"       "NOLIST"          "NOLMAP"          "NOMAP"
    276. 

  276.      "NON-SHARED"      "NONSTOP"         "NOPORT"          "NOSAVEABEND"
    277. 

  277.      "NOSEARCH"        "NOSHOWCOPY"      "NOSHOWFILE"      "NOSQL"
    278. 

  278.      "NOSUPPRESS"      "NOSYMBOLS"       "NOTRAP2"         "NOTRAP2-74"
    279. 

  279.      "NOWARN"          "OPTIMIZE"        "PERFORM-TRACE"   "PORT"
    280. 

  280.      "RESETTOG"        "RUNNABLE"        "RUNNAMED"        "SAVE"
    281. 

  281.      "SAVEABEND"       "SEARCH"          "SECTION"         "SETTOG"
    282. 

  282.      "SHARED"          "SHOWCOPY"        "SHOWFILE"        "SOURCE"
    283. 

  283.      "SQL"             "SQLMEM"          "SUBSET"          "SUBTYPE"
    284. 

  284.      "SUPPRESS"        "SYMBOLS"         "SYNTAX"          "TANDEM"
    285. 

  285.      "TRAP2"           "TRAP2-74"        "UL"              "WARN")
    286. 

  286.   "List of NMCOBOL compiler directives.
    287. 

  287. Used to create the `font-lock-keywords' table.")
    288. 

    289. 

  289. (defvar nmcobol-keywords-imperatives
    290. 

  290.   '( "ACCEPT"        "DISPLAY"       "MULTIPLY"      "STOP"
    291. 

  291.      "ADD"           "DIVIDE"        "OPEN"          "STRING"
    292. 

  292.      "ALTER"         "ENTER"         "PERFORM"       "SUBTRACT"
    293. 

  293.      "CALL"          "EXIT"          "READ"          "UNLOCKFILE"
    294. 

  294.      "CANCEL"        "GO TO"         "RELEASE"       "UNLOCKRECORD"
    295. 

  295.      "INITIALIZE"    "REWRITE"       "UNSTRING"      "CLOSE"
    296. 

  296.      "INSPECT"       "SET"           "WRITE"         "COMPUTE"
    297. 

  297.      "LOCKFILE"      "SORT"          "CONTINUE"      "MERGE"
    298. 

  298.      "START"         "DELETE"        "MOVE")
    299. 

  299.   "List of NMCOBOL keywords identifying an imperative statement.
    300. 

  300. Used by indentation routines in their determination of such."
    301. 

  301. )
    302. 

    303. 

  303. (defvar nmcobol-block-keywords
    304. 

  304.   '("ADD"            "COMPUTE"        "DELETE"         "DIVIDE"
    305. 

  305.     "EVALUATE"       "IF"             "MULTIPLY"       "PERFORM"
    306. 

  306.     "READ"           "REWRITE"        "SEARCH"         "START"
    307. 

  307.     "STRING"         "SUBTRACT"       "UNSTRING"       "WRITE"
    308. 

  308.    )
    309. 

  309.   "A list of words that should have open paren syntax - conditionally.
    310. 

  310. `nmcobol-get-block-type' determines if they actually require the
    311. 

  311. END-<word> statement." )
    312. 

    313. 

  313. (defvar nmcobol-keywords-statements     ;font-lock-keyword-face
    314. 

  314.   '("ACCEPT"        "ADD"           "ALTER"         "CALL"          
    315. 

  315.     "CANCEL"        "CHECKPOINT"    "CLOSE"         "COMPUTE"       
    316. 

  316.     "CONTINUE"      "COPY"          "DELETE"        "DISPLAY"       
    317. 

  317.     "DIVIDE"        "ELSE"          "END"           "END-ADD"       
    318. 

  318.     "END-COMPUTE"   "END-DELETE"    "END-DIVIDE"    "END-EVALUATE"  
    319. 

  319.     "END-IF"        "END-MULTIPLY"  "END-OF-PAGE"   "END-PERFORM"   
    320. 

  320.     "END-READ"      "END-RECEIVE"   "END-RETURN"    "END-REWRITE"   
    321. 

  321.     "END-SEARCH"    "END-START"     "END-STRING"    "END-SUBTRACT"  
    322. 

  322.     "END-UNSTRING"  "END-WRITE"     "ENTER COBOL"   "ENTER"         
    323. 

  323.     "EVALUATE"      "EXIT"          "FD"            "FILE"          
    324. 

  324.     "GO TO"         "IF"            "INITIALIZE"    "INSPECT"       
    325. 

  325.     "LOCKFILE"      "MERGE"         "MOVE"          "MULTIPLY"      
    326. 

  326.     "OPEN"          "PERFORM"       "READ"          "RELEASE"       
    327. 

  327.     "REPLACE"       "RETURN"        "REWRITE"       "SD"            
    328. 

  328.     "SEARCH"        "SELECT"        "SET"           "SORT"          
    329. 

  329.     "START"         "STARTBACKUP"   "STOP"          "STRING"        
    330. 

  330.     "SUBTRACT"      "THEN"          "UNLOCKFILE"    "UNLOCKRECORD"  
    331. 

  331.     "UNSTRING"      "USE"           "WHEN"          "WRITE"         )
    332. 

  332.   "List of NMCOBOL statement keywords.
    333. 

  333. Used to create the `font-lock-keywords' table.")
    334. 

    335. 

  335. (defvar nmcobol-keywords-deprecated     ;font-lock-warning-face
    336. 

  336.   '( "STARTBACKUP" "CHECKPOINT")
    337. 

  337.   "List of NMCOBOL keywords and Builtin functions now deprecated.
    338. 

  338. Used to create the `font-lock-keywords' table")
    339. 

    340. 

  340. (defvar nmcobol-keywords-reserved       ;font-lock-type-face
    341. 

  341.   '( "ACCEPT"                 "ACCESS"                 "ADD"
    342. 

  342.      "ADDRESS"                "ADVANCING"              "AFTER"
    343. 

  343.      "ALL"                    "ALPHABET"               "ALPHABETIC"
    344. 

  344.      "ALPHABETIC-LOWER"       "ALPHABETIC-UPPER"       "ALPHANUMERIC"
    345. 

  345.      "ALPHANUMERIC-EDITED"    "ALSO"                   "ALTER"
    346. 

  346.      "ALTERNATE"              "AND"                    "ANY"
    347. 

  347.      "APPROXIMATE"            "AREA"                   "AREAS"
    348. 

  348.      "ASCENDING"              "ASSIGN"                 "AT"
    349. 

  349.      "AUTHOR"                 "BEFORE"                 "BINARY"
    350. 

  350.      "BLANK"                  "BLOCK"                  "BOTTOM"
    351. 

  351.      "BY"                     "CALL"                   "CANCEL"
    352. 

  352.      "CD"                     "CF"                     "CH"
    353. 

  353.      "CHARACTER"              "CHARACTERS"             "CHARACTER-SET"
    354. 

  354.      "CHECKPOINT"             "CLASS"                  "CLOCK-UNITS"
    355. 

  355.      "CLOSE"                  "COBOL"                  "CODE"
    356. 

  356.      "CODE-SET"               "COLLATING"              "COLUMN"
    357. 

  357.      "COMMA"                  "COMMON"                 "COMMUNICATION"
    358. 

  358.      "COMP"                   "COMP-3"                 "COMP-5"
    359. 

  359.      "COMPUTATIONAL"          "COMPUTATIONAL-3"        "COMPUTATIONAL-5"
    360. 

  360.      "COMPUTE"                "CONFIGURATION"          "CONTAINS"
    361. 

  361.      "CONTENT"                "CONTINUE"               "CONTROL"
    362. 

  362.      "CONTROLS"               "CONVERTING"             "COPY"
    363. 

  363.      "CORR"                   "CORRESPONDING"          "COUNT"
    364. 

  364.      "CURRENCY"               "DATA"                   "DATE"
    365. 

  365.      "DATE-COMPILED"          "DATE-WRITTEN"           "DAY"
    366. 

  366.      "DAY-OF-WEEK"            "DE"                     "DEBUG-CONTENTS"
    367. 

  367.      "DEBUG-ITEM"             "DEBUG-LINE"             "DEBUG-SUB-2"
    368. 

  368.      "DEBUG-SUB-3"            "DEBUGGING"              "DECIMAL-POINT"
    369. 

  369.      "DECLARATIVES"           "DEBUG-NAME"             "DEBUG-SUB-1"
    370. 

  370.      "DELETE"                 "DELIMITED"              "DELIMITER"
    371. 

  371.      "DEPENDING"              "DESCENDING"             "DESTINATION"
    372. 

  372.      "DETAIL"                 "DISABLE"                "DISPLAY"
    373. 

  373.      "DIVIDE"                 "DIVISION"               "DOWN"
    374. 

  374.      "DUPLICATES"             "DYNAMIC"                "EGI"
    375. 

  375.      "ELSE"                   "EMI"                    "ENABLE"
    376. 

  376.      "END"                    "END-ADD"                "END-COMPUTE"
    377. 

  377.      "END-DELETE"             "END-DIVIDE"             "END-EVALUATE"
    378. 

  378.      "END-IF"                 "END-MULTIPLY"           "END-OF-PAGE"
    379. 

  379.      "END-PERFORM"            "END-READ"               "END-RECEIVE"
    380. 

  380.      "END-RETURN"             "END-REWRITE"            "END-SEARCH"
    381. 

  381.      "END-START"              "END-STRING"             "END-SUBTRACT"
    382. 

  382.      "END-UNSTRING"           "END-WRITE"              "ENTER"
    383. 

  383.      "EOP"                    "EQUAL"                  "ERROR"
    384. 

  384.      "ESI"                    "EVALUATE"               "EVERY"
    385. 

  385.      "EXCEPTION"              "EXCLUSIVE"              "EXIT"
    386. 

  386.      "EXTEND"                 "EXTENDED-STORAGE"       "EXTERNAL"
    387. 

  387.      "FALSE"                  "FD"                     "FILE"
    388. 

  388.      "FILE-CONTROL"           "FILLER"                 "FINAL"
    389. 

  389.      "FIRST"                  "FOOTING"                "FOR"
    390. 

  390.      "FROM"                   "FUNCTION"               "GENERATE"
    391. 

  391.      "GENERIC"                "GIVING"                 "GLOBAL"
    392. 

  392.      "GO"                     "GREATER"                "GROUP"
    393. 

  393.      "GUARDIAN-ERR"           "HEADING"                "HIGH-VALUE"
    394. 

  394.      "HIGH-VALUES"            "I-O"                    "I-O-CONTROL"
    395. 

  395.      "IDENTIFICATION"         "IF"                     "IN"
    396. 

  396.      "INDEX"                  "INDEXED"                "INDICATE"
    397. 

  397.      "INITIAL"                "INITIALIZE"             "INITIATE"
    398. 

  398.      "INPUT"                  "INPUT-OUTPUT"           "INSPECT"
    399. 

  399.      "INSTALLATION"           "INTO"                   "INVALID"
    400. 

  400.      "IS"                     "JUST"                   "JUSTIFIED"
    401. 

  401.      "KEY"                    "LABEL"                  "LAST"
    402. 

  402.      "LEADING"                "LEFT"                   "LENGTH"
    403. 

  403.      "LESS"                   "LIMIT"                  "LIMITS"
    404. 

  404.      "LINAGE"                 "LINAGE-COUNTER"         "LINE"
    405. 

  405.      "LINE-COUNTER"           "LINKAGE"                "LOCK"
    406. 

  406.      "LOCKFILE"               "LOW-VALUE"              "LOW-VALUES"
    407. 

  407.      "MEMORY"                 "MERGE"                  "MESSAGE"
    408. 

  408.      "MODE"                   "MODULES"                "MOVE"
    409. 

  409.      "MULTIPLE"               "MULTIPLY"               "NATIVE"
    410. 

  410.      "NEGATIVE"               "NEXT"                   "NO"
    411. 

  411.      "NOT"                    "NULL"                   "NULLS"
    412. 

  412.      "NUMBER"                 "NUMERIC"                "NUMERIC-EDITED"
    413. 

  413.      "OBJECT-COMPUTER"        "OCCURS"                 "OF"
    414. 

  414.      "OFF"                    "OMITTED"                "ON"
    415. 

  415.      "OPEN"                   "OPTIONAL"               "OR"
    416. 

  416.      "ORDER"                  "ORGANIZATION"           "OTHER"
    417. 

  417.      "OUTPUT"                 "OVERFLOW"               "PACKED-DECIMAL"
    418. 

  418.      "PADDING"                "PAGE"                   "PAGE-COUNTER"
    419. 

  419.      "PERFORM"                "PF"                     "PH"
    420. 

  420.      "PIC"                    "PICTURE"                "PLUS"
    421. 

  421.      "POINTER"                "POSITION"               "POSITIVE"
    422. 

  422.      "PRINTING"               "PROCEDURE"              "PROCEDURES"
    423. 

  423.      "PROCEED"                "PROGRAM"                "PROGRAM-ID"
    424. 

  424.      "PROGRAM-STATUS"         "PROGRAM-STATUS-1"       "PROGRAM-STATUS-2"
    425. 

  425.      "PROMPT"                 "PROTECTED"              "PURGE"
    426. 

  426.      "QUEUE"                  "QUOTE"                  "QUOTES"
    427. 

  427.      "RANDOM"                 "RD"                     "READ"
    428. 

  428.      "RECEIVE"                "RECEIVE-CONTROL"        "RECORD"
    429. 

  429.      "RECORDS"                "REDEFINES"              "REEL"
    430. 

  430.      "REFERENCE"              "REFERENCES"             "RELATIVE"
    431. 

  431.      "RELEASE"                "REMAINDER"              "REMOVAL"
    432. 

  432.      "RENAMES"                "REPLACE"                "REPLACING"
    433. 

  433.      "REPLY"                  "REPORT"                 "REPORTING"
    434. 

  434.      "REPORTS"                "RERUN"                  "RESERVE"
    435. 

  435.      "RESET"                  "RETURN"                 "REVERSED"
    436. 

  436.      "REWIND"                 "REWRITE"                "RF"
    437. 

  437.      "RH"                     "RIGHT"                  "ROUNDED"
    438. 

  438.      "RUN"                    "SAME"                   "SD"
    439. 

  439.      "SEARCH"                 "SECTION"                "SECURITY"
    440. 

  440.      "SEGMENT"                "SEGMENT-LIMIT"          "SELECT"
    441. 

  441.      "SEND"                   "SENTENCE"               "SEPARATE"
    442. 

  442.      "SEQUENCE"               "SEQUENTIAL"             "SET"
    443. 

  443.      "SHARED"                 "SIGN"                   "SIZE"
    444. 

  444.      "SORT"                   "SORT-MERGE"             "SOURCE"
    445. 

  445.      "SOURCE-COMPUTER"        "SPACE"                  "SPACES"
    446. 

  446.      "SPECIAL-NAMES"          "STANDARD"               "STANDARD-1"
    447. 

  447.      "STANDARD-2"             "START"                  "STARTBACKUP"
    448. 

  448.      "STATUS"                 "STOP"                   "STRING"
    449. 

  449.      "SUB-QUEUE-1"            "SUB-QUEUE-2"            "SUB-QUEUE-3"
    450. 

  450.      "SUBTRACT"               "SUM"                    "SUPPRESS"
    451. 

  451.      "SYMBOLIC"               "SYNC"                   "SYNCDEPTH"
    452. 

  452.      "SYNCHRONIZED"           "TABLE"                  "TAL"
    453. 

  453.      "TALLYING"               "TAPE"                   "TERMINAL"
    454. 

  454.      "TERMINATE"              "TEST"                   "TEXT"
    455. 

  455.      "THAN"                   "THEN"                   "THROUGH"
    456. 

  456.      "THRU"                   "TIME"                   "TIMES"
    457. 

  457.      "TO"                     "TOP"                    "TRAILING"
    458. 

  458.      "TRUE"                   "TYPE"                   "UNIT"
    459. 

  459.      "UNLOCK"                 "UNLOCKFILE"             "UNLOCKRECORD"
    460. 

  460.      "UNSTRING"               "UNTIL"                  "UP"
    461. 

  461.      "UPON"                   "USAGE"                  "USE"
    462. 

  462.      "USING"                  "VALUE"                  "VALUES"
    463. 

  463.      "VARYING"                "WHEN"                   "WITH"
    464. 

  464.      "WORDS"                  "WORKING-STORAGE"        "WRITE"
    465. 

  465.      "ZERO"                   "ZEROES")
    466. 

  466.   "List of NMCOBOL keywords reserved only in certain language contexts.
    467. 

  467. Used to create the `font-lock-keywords' table.")
    468. 

    469. 

  469. (defvar nmcobol-keywords-std-fcns       ;font-lock-keyword-face
    470. 

  470.   '( "ACOS"                   "ANNUITY"                "ASIN"
    471. 

  471.      "ATAN"                   "CHAR"                   "COS"
    472. 

  472.      "CURRENT-DATE"           "DATE-OF-INTEGER"        "DAY-OF-INTEGER"
    473. 

  473.      "FACTORIAL"              "INTEGER"                "INTEGER-OF-DATE"
    474. 

  474.      "INTEGER-OF-DAY"         "INTEGER-PART"           "LENGTH"
    475. 

  475.      "LOG"                    "LOG10"                  "LOWER-CASE"
    476. 

  476.      "MAX"                    "MEAN"                   "MEDIAN"
    477. 

  477.      "MIDRANGE"               "MIN"                    "MOD"
    478. 

  478.      "NUMVAL"                 "NUMVAL-C"               "ORD"
    479. 

  479.      "ORD-MAX"                "ORD-MIN"                "PRESENT-VALUE"
    480. 

  480.      "RANDOM"                 "RANGE"                  "REM"
    481. 

  481.      "REVERSE"                "SIN"                    "SQRT"
    482. 

  482.      "STANDARD-DEVIATION"     "SUM"                    "TAN"
    483. 

  483.      "UPPER-CASE"             "VARIANCE"               "WHEN-COMPILED")
    484. 

  484.   "List of NMCOBOL standard functions.
    485. 

  485. Used to create the `font-lock-keywords' table.")
    486. 

    487. 

  487. (defvar nmcobol-keywords-privileged     ;font-lock-warning-face
    488. 

  488.   '( "END-EXEC" "EXEC")
    489. 

  489.   "List of NMCOBOL privileged functions.
    490. 

  490. Used to create the `font-lock-keywords' table.")
    491. 

    492. 

  492. (defvar nmcobol-keywords-builtin        ;font-lock-variable-name-face
    493. 

  493.   '( "#IN"                             "#OUT"
    494. 

  494.      "#TERM"                           "#TEMP"
    495. 

  495.      "#DYNAMIC"                        "COBOL85^ARMTRAP"
    496. 

  496.      "COBOL85^COMPLETION"              "COBOL_COMPLETION_"
    497. 

  497.      "COBOL_CONTROL_"                  "COBOL_GETENV_"
    498. 

  498.      "COBOL_PUTENV_"                   "COBOL85^RETURN^SORT^ERRORS"
    499. 

  499.      "COBOL_RETURN_SORT_ERRORS_"       "COBOL85^REWIND^SEQUENTIAL"
    500. 

  500.      "COBOL_REWIND_SEQUENTIAL_"        "COBOL85^SET^SORT^PARAM^TEXT"
    501. 

  501.      "COBOL_SET_SORT_PARAM_TEXT_"      "COBOL85^SET^SORT^PARAM^VALUE"
    502. 

  502.      "COBOL_SET_SORT_PARAM_VALUE_"     "COBOL_SET_MAX_RECORD_"
    503. 

  503.      "COBOL_SETMODE_"                  "COBOL85^SPECIAL^OPEN"
    504. 

  504.      "COBOL_SPECIAL_OPEN_"             "COBOLASSIGN"
    505. 

  505.      "COBOL_ASSIGN_"                   "COBOLFILEINFO"
    506. 

  506.      "COBOL_FILE_INFO_"                "COBOLSPOOLOPEN"
    507. 

  507.      "CREATEPROCESS"                   "ALTERPARAMTEXT"
    508. 

  508.      "CHECKLOGICALNAME"                "CHECKMESSAGE"
    509. 

  509.      "DELETEASSIGN"                    "DELETEPARAM"
    510. 

  510.      "DELETESTARTUP"                   "GETASSIGNTEXT"
    511. 

  511.      "GETASSIGNVALUE"                  "GETBACKUPCPU"
    512. 

  512.      "GETPARAMTEXT"                    "GETSTARTUPTEXT"
    513. 

  513.      "PUTASSIGNTEXT"                   "PUTASSIGNVALUE"
    514. 

  514.      "PUTPARAMTEXT"                    "PUTSTARTUPTEXT")
    515. 

  515.   "List of NMCOBOL privileged builtin functions.
    516. 

  516. Used to create the `font-lock-keywords' table.")
    517. 

    518. 

  518. (defcustom nmcobol-block-always-keywords
    519. 

  519.   '("ELSE"      "EVALUATE"  "IF"        "SEARCH"    "THEN"      
    520. 

  520.     "WHEN"      )
    521. 

  521.   "List of keywords that always require and END-<word>. Used in paren matching."
    522. 

  522.   :type  '(repeat (string :tag "word"))
    523. 

  523.   :group 'nmcobol)
    524. 

    525. 

  525. (defcustom nmcobol-keyword-section-names-regexp
    526. 

  526.   "^\\s-\\{1,3\\}\\(\\w+\\)\\s-+\\(division\\(\\s-+using\\s-+[^.\n]+\\)?\\|section\\) *\\."
    527. 

  527.   "Defines a regexp that finds the names of divisions & sections.
    528. 

  528. Used to create the `font-lock-keywords' table."
    529. 

  529.   :type  'regexp
    530. 

  530.   :group 'nmcobol)
    531. 

    532. 

  532. (defcustom nmcobol-keyword-fcn-names-regexp
    533. 

  533.   "^\\s-\\{1,3\\}\\(\\w+\\)\\s-*\\."
    534. 

  534.   "Defines a regexp that finds the names of paragraphs.
    535. 

  535. Used by `font-lock-keywords'. See also `nmcobol-imenu-fcn-names-regexp'"
    536. 

  536.   :type  'regexp
    537. 

  537.   :group 'nmcobol)
    538. 

    539. 

  539. ;;; Build keyword regexp from keyword lists
    540. 

  540. 

  541. (defvar nmcobol-keywords-imperatives-regexp ()
    542. 

  542.   "regexp matching `nmcobol-keywords-imperatives'")
    543. 

  543. (defvar nmcobol-keywords-statements-regexp ()
    544. 

  544.   "regexp matching `nmcobol-keywords-statements'")
    545. 

  545. (defvar nmcobol-keywords-reserved-regexp ()
    546. 

  546.   "regexp matching `nmcobol-keywords-reserved'")
    547. 

  547. (defvar nmcobol-block-always-regexp ()
    548. 

  548.   "regexp matching `nmcobol-block-always-keywords'")
    549. 

  549. (defvar nmcobol-block-begin-regexp ()
    550. 

  550.   "regexp matching `nmcobol-block-keywords'")
    551. 

  551. (defvar nmcobol-block-end-regexp ()
    552. 

  552.   "regexp matching \"END-\" + `nmcobol-block-keywords'")
    553. 

  553. (defvar nmcobol-non-cobol-regexp
    554. 

  554.   "^[*/?]"
    555. 

  555.   "Expression describing comment and compiler directive lines.")
    556. 

  556. 

  557. (defun nmcobol-setup-regexp-vars ()
    558. 

  558.   "Rebuilds regexp variables from keyword lists."
    559. 

  559.   (setq nmcobol-keywords-imperatives-regexp
    560. 

  560.         (concat (regexp-opt nmcobol-keywords-imperatives t) "\\(\\s-\\|\\.\\)")
    561. 

  561.         nmcobol-keywords-statements-regexp
    562. 

  562.         (concat "^\\([ \t]+\\)"
    563. 

  563.                 (regexp-opt nmcobol-keywords-statements t) "\\(\\s-\\|\\.\\)")
    564. 

  564.         nmcobol-keywords-reserved-regexp ;not used!
    565. 

  565.         (nmcobol-keyword-anywhere-regexp nmcobol-keywords-reserved)
    566. 

  566.         nmcobol-block-always-regexp
    567. 

  567.         (concat (regexp-opt nmcobol-block-always-keywords t) "\\(\\s-\\|\\.\\)")
    568. 

  568.         nmcobol-block-begin-regexp
    569. 

  569.         (regexp-opt nmcobol-block-keywords  t)
    570. 

  570.         nmcobol-block-end-regexp
    571. 

  571.         (concat "END-" (regexp-opt nmcobol-block-keywords  t))))
    572. 

  572. 

  573. ;;; Font lock (highlighting)
    574. 

  574. 

  575. (defcustom nmcobol-font-lock-always t
    576. 

  576.   "`nmcobol-mode' makes sure `font-lock-mode' is on for nmcobol-mode buffers.
    577. 

  577. Some things don't work if it's off so insuring it's on is the default."
    578. 

  578.   :type 'boolean
    579. 

  579.   :group 'nmcobol)
    580. 

    581. 

  581. (defcustom nmcobol-primecode-warning t
    582. 

  582.   "Highlight instances of ]a ]d and ]e in column 1 with a warning face.
    583. 

  583. This alerts you that submission of this file to RMS/PrimeCode will fail
    584. 

  584. due to invalid contents.  nil disables this warning."
    585. 

  585.   :type 'boolean
    586. 

  586.   :group 'nmcobol)
    587. 

    588. 

  588. (defun nmcobol-keyword-special-regexp ( word-list )
    589. 

  589.   "Returns a regexp that finds any of the words in WORD-LIST.
    590. 

  590. But only if the keyword is surrounded by non-word chars."
    591. 

  591.   (concat "\\W"(regexp-opt word-list t)"\\W"))
    592. 

  592. 

  593. (defun nmcobol-keyword-anywhere-regexp ( word-list )
    594. 

  594.   "Returns a regexp that finds any of the words in WORD-LIST.
    595. 

  595. But only if the keyword is surrounded by non-word chars."
    596. 

  596.   (concat "\\b"(regexp-opt word-list t)"\\b"))
    597. 

  597. 

  598. ;; The next 4 def's work tightly together and, as coded, cannot be reused for
    599. 

  599. ;; additional purposes.
    600. 

  600. (defvar nmcobol-keyword-on-directive-line-regexp () "Internal use only.")
    601. 

  601. (defun  nmcobol-keyword-on-directive-line-regexp ( word-list )
    602. 

  602. "Returns a function to find WORD-LIST only if line starts with ?"
    603. 

  603.   (setq nmcobol-keyword-on-directive-line-regexp
    604. 

  604.         (concat "\\b"(regexp-opt word-list t)"\\b"))
    605. 

  605.   'nmcobol-font-lock-directive-line)
    606. 

  606. (defvar nmcobol-amid-font-lock-excursion nil
    607. 

  607.   "Used by `nmcobol-font-lock-directive-line'.  When a line starting with
    608. 

  608. ? in column 1 is detected this variable holds the context needed to
    609. 

  609. continue searching for more keywords.  If nil a line starting with ?
    610. 

  610. should be searched for.")
    611. 

  611. (make-variable-buffer-local 'nmcobol-amid-font-lock-excursion)
    612. 

  612. (defun nmcobol-font-lock-directive-line ( search-limit )
    613. 

  613.   "This function finds keywords only in lines starting with ?.  Valid
    614. 

  614. keywords are described by `nmcobol-keyword-on-directive-line-regexp'.
    615. 

  615. First a line beginning with ? is searched for.  Once found, point is
    616. 

  616. moved to the beginning of that area and limit is set to the end.
    617. 

  617. Keywords are searched for within that range.  If found, context is saved
    618. 

  618. in nmcobol-amid-font-lock-excursion and the match-data is returned.  If
    619. 

  619. not found, another line starting with ?  is searched for.  If saved
    620. 

  620. context exists when this function is called then another keyword is
    621. 

  621. searched for in the previously narrowed region.  If none is found the
    622. 

  622. next region is searched for."
    623. 

  623.   (let ((looking t))
    624. 

  624.     (while
    625. 

  625.         (and looking
    626. 

  626.              (or nmcobol-amid-font-lock-excursion
    627. 

  627.           (when (re-search-forward "^\\?.+\n" search-limit t)
    628. 

  628.             (setq nmcobol-amid-font-lock-excursion (point))
    629. 

  629.             (goto-char (match-beginning 0)))))
    630. 

  630.       (if (re-search-forward nmcobol-keyword-on-directive-line-regexp
    631. 

  631.                nmcobol-amid-font-lock-excursion t)
    632. 

  632.           (setq looking nil)
    633. 

  633.         (goto-char nmcobol-amid-font-lock-excursion)
    634. 

  634.         (setq nmcobol-amid-font-lock-excursion nil)))
    635. 

  635.     (not looking)))
    636. 

    637. 

  637. (defvar nmcobol-find-syntactic--state ()
    638. 

  638.   "Used by `nmcobol-find-syntactic-keywords' to find multiple syntactic
    639. 

  639. elements which all must be anchored to the beginning of a line.
    640. 

  640. nil    = No searches on this line yet. skip line if it's a directive.
    641. 

  641. 0      = look for sequence number in col 1-6 (removed)
    642. 

  642. 1      = sequence/label area checked. look at body.
    643. 

  643. 2      = body not a comment, any trailing comment marked, check for strings
    644. 

  644. marker = terminated string found check for more.")
    645. 

  645. (make-variable-buffer-local 'nmcobol-find-syntactic--state)
    646. 

  646. (defun nmcobol-find-syntactic-keywords ( search-limit )
    647. 

  647.   "Used by `font-lock-syntactic-keywords' to find comments and strings.
    648. 

  648. Returns t if either a comment or string is found, nil if neither is found.
    649. 

  649. match-data 1&2 are set for comments, 3&4 are set for a normal string, 5&6 are
    650. 

  650. set for eol-terminated strings.  Where the match pair mark the start character
    651. 

  651. and end character respectively.  Point is moved to the next line during this
    652. 

  652. function only after the last search completes for the current line.  A state
    653. 

  653. machine, controlled by `nmcobol-find-syntactic--state' sequences the searches."
    654. 

  654.   (let ((found nil)
    655. 

  655.         (save (point)))
    656. 

  656.     (while (and (< (point) search-limit)
    657. 

  657.                 (not found))
    658. 

  658.            (cond
    659. 

  659.             ;; no comments or quotes? in compiler directives
    660. 

  660.             ((or (null nmcobol-find-syntactic--state)
    661. 

  661.                  (equal nmcobol-find-syntactic--state (make-marker)))
    662. 

  662.              (if (looking-at "^\\?")
    663. 

  663.                  (forward-line 1)       ;do this state on next line
    664. 

  664.                (setq nmcobol-find-syntactic--state 1) ;do next state on this line
    665. 

  665.              ))
    666. 

  666.             ;; see if entire line is a comment
    667. 

  667.             ((= 1 nmcobol-find-syntactic--state)
    668. 

  668.              (if (not (looking-at "^\\(?:*\\|/\\)"))
    669. 

  669.                  (setq nmcobol-find-syntactic--state 2) ;goto next state
    670. 

  670.                ;; else set match data and point to next line
    671. 

  671.                (looking-at "\\(.\\).*\\(\n\\|\\'\\)") ;setup match-data
    672. 

  672.                (forward-line 1)    ;next iteration looks at next line
    673. 

  673.                (setq nmcobol-find-syntactic--state ()
    674. 

  674.                      found t)))
    675. 

  675.             ;; look for strings only within columns 8-72 inclusive
    676. 

  676.             ((= 2 nmcobol-find-syntactic--state)
    677. 

  677.              (if (looking-at "^[-d D][^\"\n]\\{0,130\\}\"")
    678. 

  678.                  (let* ((open-quote (list (copy-marker (1- (match-end 0)))
    679. 

  679.                                           (copy-marker (match-end 0))))
    680. 

  680.                         (leol (copy-marker (line-end-position)))
    681. 

  681.                         close-quote)
    682. 

  682.                    (setq found t)
    683. 

  683.                    (goto-char (cadr open-quote))
    684. 

  684.                    (if (search-forward "\"" leol t)
    685. 

  685.                        (progn           ; normally ending string
    686. 

  686.                          (setq close-quote (match-data)
    687. 

  687.                                nmcobol-find-syntactic--state (cadr close-quote))
    688. 

  688.                          (beginning-of-line)
    689. 

  689.                          (set-match-data
    690. 

  690.                           `(,(car open-quote) ,(cadr close-quote)
    691. 

  691.                             nil nil nil nil ;match-string 1&2 not found
    692. 

  692.                             ,@open-quote ,@close-quote)) ;3&4 are normal string
    693. 

  693.                        )
    694. 

  694.                      ;; implicit string end
    695. 

  695.                      (forward-line 1)   ;next iteration looks at next line
    696. 

  696.                      (setq close-quote (list (copy-marker (1- leol)) leol)
    697. 

  697.                            nmcobol-find-syntactic--state ())
    698. 

  698.                      (set-match-data
    699. 

  699.                       `(,(car open-quote) ,(cadr close-quote)
    700. 

  700.                         nil nil nil nil ;match-string 1&2 not found
    701. 

  701.                         nil nil nil nil ;match-string 3&4 not found
    702. 

  702.                         ,@open-quote ,@close-quote)) ;5&6 unterminated string
    703. 

  703.                    ))
    704. 

  704.                ;; no string was found.  Start new analysis on next line
    705. 

  705.                (forward-line 1)
    706. 

  706.                (setq nmcobol-find-syntactic--state ())))
    707. 

  707.             ;; a string has been found look for another after it
    708. 

  708.             ((markerp nmcobol-find-syntactic--state)
    709. 

  709.              (let ((leol (copy-marker (line-end-position)))
    710. 

  710.                    open-quote close-quote)
    711. 

  711.                (goto-char nmcobol-find-syntactic--state)
    712. 

  712.                (if (search-forward "\"" leol t)
    713. 

  713.                    (progn
    714. 

  714.                      (setq open-quote (match-data)
    715. 

  715.                            found t)
    716. 

  716.                      (if (search-forward "\"" leol t)
    717. 

  717.                          (progn         ; normally ending string
    718. 

  718.                            (beginning-of-line) ;next iteration starts here again
    719. 

  719.                            (setq close-quote (match-data)
    720. 

  720.                                  nmcobol-find-syntactic--state (cadr close-quote))
    721. 

  721.                            (set-match-data
    722. 

  722.                             `(,(car open-quote) ,(cadr close-quote)
    723. 

  723.                               nil nil nil nil ;match-string 1&2 not found
    724. 

  724.                               ,@open-quote ,@close-quote)) ;3&4 normal string
    725. 

  725.                          )
    726. 

  726.                        ;; implicit string end
    727. 

  727.                        (forward-line 1) ;next iteration looks at next line
    728. 

  728.                        (setq close-quote (list (copy-marker (1- leol)) leol)
    729. 

  729.                              nmcobol-find-syntactic--state ())
    730. 

  730.                        (set-match-data
    731. 

  731.                         `(,(car open-quote) ,(cadr close-quote)
    732. 

  732.                           nil nil nil nil ;match-string 1&2 not found
    733. 

  733.                           nil nil nil nil ;match-string 3&4 not found
    734. 

  734.                           ,@open-quote ,@close-quote)) ;5&6 unterminated string
    735. 

  735.                      ))
    736. 

  736.                  (forward-line 1)
    737. 

  737.                  (setq nmcobol-find-syntactic--state ()))))))
    738. 

  738.     ;; Point should not return forward of search-limit
    739. 

  739.     (and (> (point) search-limit) (goto-char search-limit))
    740. 

  740.     ;; point shouldn't move if nothing was found.
    741. 

  741.     (prog1 found (or found (goto-char save)))))
    742. 

    743. 

  743. (defvar nmcobol-static-font-lock-keywords
    744. 

  744.   ;; font-lock-keywords is a symbol or list of symbols yielding the keywords to
    745. 

  745.   ;; be fontified.  Keywords are listed here using either (MATCHER . FACENAME)
    746. 

  746.   ;; or (MATCHER . (MATCH FACENAME)) syntax.  Other options are available but
    747. 

  747.   ;; not used here.  For simplicity, all regexp's were designed so MATCH would
    748. 

  748.   ;; be 1.  Nothing forced this but to me it makes debug/maintenance easier.
    749. 

  749.   `(("^\\([^ ?Dd*/-]\\)" 1 font-lock-warning-face)
    750. 

  750.     ("^\\([?Dd-]\\)"     1 font-lock-builtin-face)
    751. 

  751.     (,nmcobol-keyword-section-names-regexp
    752. 

  752.      1 font-lock-function-name-face)
    753. 

  753.     (,(nmcobol-keyword-on-directive-line-regexp nmcobol-keywords-directives)
    754. 

  754.      1 font-lock-preprocessor-face)
    755. 

  755.     (,(nmcobol-keyword-anywhere-regexp          nmcobol-keywords-builtin)
    756. 

  756.      1 font-lock-variable-name-face)
    757. 

  757.     (,(nmcobol-keyword-special-regexp           nmcobol-keywords-statements)
    758. 

  758.      1 font-lock-keyword-face)
    759. 

  759.     (,(nmcobol-keyword-anywhere-regexp          nmcobol-keywords-std-fcns)
    760. 

  760.      1 font-lock-keyword-face)
    761. 

  761.     (,(nmcobol-keyword-anywhere-regexp (append  nmcobol-keywords-deprecated
    762. 

  762.                                                 nmcobol-keywords-privileged))
    763. 

  763.      1 font-lock-warning-face)
    764. 

  764.     (,(nmcobol-keyword-anywhere-regexp          nmcobol-keywords-reserved)
    765. 

  765.      1 font-lock-type-face)
    766. 

  766.     (,nmcobol-keyword-fcn-names-regexp
    767. 

  767.      1 font-lock-function-name-face)))
    768. 

  768. 

  769. (defvar nmcobol-font-lock-keywords ())
    770. 

  770. (defun nmcobol-build-font-lock-keywords ()
    771. 

  771.   "Creates `font-lock-keywords' based on current customize settings."
    772. 

  772.   (append nmcobol-static-font-lock-keywords
    773. 

  773.           `(,(when nmcobol-primecode-warning
    774. 

  774.                ;; ]a  ]d or ]e cannot appear in col 1-2 if using PrimeCode.
    775. 

  775.                '("^\\][ade]" . font-lock-warning-face)))))
    776. 

    777. 

  777. (defvar nmcobol-this-paren-type ()
    778. 

  778.   "Used internally by `nmcobol-font-lock-syntactic-keywords'"
    779. 

  779. )
    780. 

  780. 

  781. (defvar nmcobol-block-symbol-prefix "nmcobol-blk-typ-"
    782. 

  782.   "Paren matching symbols are built using this prefix.
    783. 

  783. You probably don't want to change it "
    784. 

  784. )
    785. 

  785. 

  786. (defcustom nmcobol-else-gets-paren-syntax t
    787. 

  787.   "When `show-paren-mode' is ON and this is nil, IF always matches END-IF only.
    788. 

  788. When this variable is non-nil, IF can match ELSE and ELSE matches END-IF."
    789. 

  789.   :type 'boolean
    790. 

  790.   :group 'nmcobol)
    791. 

    792. 

  792. (defun nmcobol-find-paren-words (lim)
    793. 

  793.   "Function to set paren syntactic properties for Cobol's block keywords.
    794. 

  794. Returns t and sets both `nmcobol-this-paren-type' and appropriate match-data
    795. 

  795. when keywords requiring paren syntax are seen within range of point & lim."
    796. 

  796.   (let ((looking t)   ;looping continues until lim or found (not looking)
    797. 

  797.         open-type               ;type of paren needed to match this open
    798. 

  798.         close-type              ;type of paren needed to match this close
    799. 

  799.         open-loc
    800. 

  800.         close-loc
    801. 

  801.         word)
    802. 

  802.     ;; walk thru each statement
    803. 

  803.     (while (and looking
    804. 

  804.                 (re-search-forward nmcobol-keywords-statements-regexp
    805. 

  805.                                    lim 'move-anyway))
    806. 

  806.       ;; Save the word and it's location in case paren class is to be applied
    807. 

  807.       (setq word (match-string-no-properties 2)
    808. 

  808.             open-loc (match-beginning 2)
    809. 

  809.             close-loc (1- (match-end 2)))
    810. 

  810.       ;; Look for the different types of paren class we might apply
    811. 

  811.       (cond
    812. 

  812.        ;; The ELSE keyword can be ignored or treated as both open and close
    813. 

  813.        ((and nmcobol-else-gets-paren-syntax (string= "ELSE" word))
    814. 

  814.         ;; The leading E of Else will match the I of IF and the trailing
    815. 

  815.         ;; E should match the F of END-IF.  When no ELSE is present the I
    816. 

  816.         ;; of IF will match the F of END-IF.
    817. 

  817.         (setq looking    nil
    818. 

  818.               word       open-loc
    819. 

  819.               open-loc   close-loc
    820. 

  820.               close-loc  word
    821. 

  821.               close-type (setq open-type
    822. 

  822.                                (intern
    823. 

  823.                                 (concat nmcobol-block-symbol-prefix "IF")))))
    824. 

    825. 

  825.        ;; close paren keywords always have close paren syntax
    826. 

  826.        ((string-match nmcobol-block-end-regexp word)
    827. 

  827.         (setq close-type
    828. 

  828.               (intern
    829. 

  829.                (concat nmcobol-block-symbol-prefix
    830. 

  830.                        (upcase (match-string-no-properties 1 word))))
    831. 

  831.               looking nil))
    832. 

    833. 

  833.        ;; 'possible' open paren keywords. More checking needed.
    834. 

  834.        ((string-match nmcobol-block-begin-regexp word)
    835. 

  835.         (let ((next (point)))
    836. 

  836.           (if (re-search-forward nmcobol-keywords-statements-regexp
    837. 

  837.                                  lim 'move-anyway)
    838. 

  838.               (setq next (match-beginning 0)))
    839. 

  839.           (goto-char open-loc)
    840. 

  840.           (if (setq open-type (nmcobol-get-block-type next))
    841. 

  841.               (setq looking nil))
    842. 

  842.           (goto-char (1+ close-loc))))))
    843. 

  843.     ;; Build the response data
    844. 

  844.     (if looking
    845. 

  845.         ;; nil is returned if no paren syntax to apply
    846. 

  846.         (set-match-data ())
    847. 

  847.       ;; both the match data and the paren type data must be set
    848. 

  848.       (set-match-data
    849. 

  849.        (append (list open-loc (1+ close-loc))
    850. 

  850.                (if open-type
    851. 

  851.                    (list open-loc (1+ open-loc))
    852. 

  852.                  (list () ()))
    853. 

  853.                (if close-type
    854. 

  854.                    (list close-loc (1+ close-loc)))))
    855. 

  855.       (setq nmcobol-this-paren-type
    856. 

  856.             (cons
    857. 

  857.              ;; declare the open-paren type
    858. 

  858.              (cons 4 open-type)
    859. 

  859.              ;; declare the close-paren type
    860. 

  860.              (cons 5 close-type)))
    861. 

  861.       ;; t must be returned iff match-data should be acted upon
    862. 

  862.       t)))
    863. 

    864. 

  864. (defvar nmcobol-font-lock-syntactic-keywords
    865. 

  865.  `(
    866. 

  866.    ;; nmcobol-find-syntactic-keywords returns matches 1&2 for comments, 3&4
    867. 

  867.    ;; for strings.  5&6 for eol terminated strings.  I must use "|"(15)
    868. 

  868.    ;; rather than "\""(7) for eol terminated strings because the begin
    869. 

  869.    ;; and end characters must be the same when "\""(7) is used.
    870. 

  870.    (nmcobol-find-syntactic-keywords (1 "<" t t)  (2 ">" t t)
    871. 

  871.                                     (3 "\"" t t) (4 "\"" t t)
    872. 

  872.                                     (5 "|" t t)  (6 "|" t t))
    873. 

  873.    ;; nmcobol-find-paren-words returns match 1 for open paren syntax and
    874. 

  874.    ;; match 2 for close paren syntax.  The car of nmcobol-this-paren-type
    875. 

  875.    ;; is used for open paren type and the cdr for close type.  The types
    876. 

  876.    ;; must be configurable due to the large number of them.
    877. 

  877.    (nmcobol-find-paren-words  (1 (car nmcobol-this-paren-type) t t)
    878. 

  878.                               (2 (cdr nmcobol-this-paren-type) t t)
    879. 

  879.    )
    880. 

  880.   )
    881. 

  881.  "A list of regexp's or functions.  Used to add syntax-table properties to
    882. 

  882. characters that can't be set by the syntax-table alone.")
    883. 

    884. 

  884. ;(defun nmcobol-start-of-statement-hook ()
    885. 

  885. ;  "Used as `font-lock-extend-region-functions' hook which see."
    886. 

  886. ;  ;; WARNING - any malfunction in this can cause emacs to enter a loop
    887. 

  887. ;  ;; that C-g will not break out of.  Your session (and all edits) will
    888. 

  888. ;  ;; be toast.
    889. 

  889. ;  ;; There seems to be no good way to suppress the warning caused by
    890. 

  890. ;  ;; accessing font-lock-beg.  It's required but apparently only
    891. 

  891. ;  ;; defined within a let statement.
    892. 

  892. ;  (goto-char font-lock-beg)
    893. 

  893. ;  (unless (bolp) (beginning-of-line))
    894. 

  894. ;  (unless (or (looking-at nmcobol-non-cobol-regexp)
    895. 

  895. ;              (looking-at nmcobol-keywords-statements-regexp))
    896. 

  896. ;      (let* ((lim (progn (nmcobol-backward-sentence 0)(point))))
    897. 

  897. ;        (goto-char font-lock-beg)
    898. 

  898. ;        (re-search-backward
    899. 

  899. ;         nmcobol-keywords-statements-regexp lim 'move-anyway)
    900. 

  900. ;        ;; If I reached the beginning of the sentence, there may be
    901. 

  901. ;        ;; comments and blank lines: they don't need refontification.
    902. 

  902. ;        (when (= (point) lim)
    903. 

  903. ;          (while (or (looking-at "^[ \t]*$")
    904. 

  904. ;                     (looking-at nmcobol-non-cobol-regexp))
    905. 

  905. ;            (forward-line)))))
    906. 

  906. ;    (unless (eq (point) font-lock-beg)
    907. 

  907. ;      (setq font-lock-beg (point))))
    908. 

  908. 

  909. (defun nmcobol-start-of-statement ()
    910. 

  910.   "Used as the syntax-begin function of `font-lock-defaults' which see."
    911. 

  911.   ;; WARNING - any malfunction in this can cause emacs to enter a loop
    912. 

  912.   ;; that C-g will not break out of.  Your session (and all edits) will
    913. 

  913.   ;; be toast.
    914. 

  914.   (unless (bolp) (beginning-of-line))
    915. 

  915.   (unless (or (looking-at nmcobol-non-cobol-regexp)
    916. 

  916.               (looking-at nmcobol-keywords-statements-regexp))
    917. 

  917.       (let* ((start (point))
    918. 

  918.              (lim (progn (nmcobol-backward-sentence 0)(point))))
    919. 

  919.         (goto-char start)
    920. 

  920.         (re-search-backward
    921. 

  921.          nmcobol-keywords-statements-regexp lim 'move-anyway)
    922. 

  922.         ;; If I reached the beginning of the sentence, there may be
    923. 

  923.         ;; comments and blank lines: they don't need refontification.
    924. 

  924.         (when (= (point) lim)
    925. 

  925.           (while (and (< (point) start)
    926. 

  926.                       (or (looking-at "^[ \t]*$")
    927. 

  927.                           (looking-at nmcobol-non-cobol-regexp)))
    928. 

  928.             (forward-line))
    929. 

  929.           (if (> (point) start)
    930. 

  930.               (goto-char start))))))
    931. 

  931. 

  932. (defun nmcobol-setup-font-lock ()
    933. 

  933.   "Sets up the buffer local value for font-lock-defaults and optionally
    934. 

  934. turns on font-lock-mode"
    935. 

  935.   ;; I use font-lock-syntactic-keywords to set some properties and I
    936. 

  936.   ;; don't want them ignored.
    937. 

  937.   (set (make-local-variable 'parse-sexp-lookup-properties) t)
    938. 

  938.   ;; I really can't imagine anyone wanting this off.
    939. 

  939.   (set (make-local-variable 'parse-sexp-ignore-comments) t)
    940. 

  940.   ;; This allows column markers to be different in separate buffers.
    941. 

  941.   (set (make-local-variable 'nmcobol-font-lock-keywords)
    942. 

  942.        (nmcobol-build-font-lock-keywords))
    943. 

  943.   ;; make sure the parsing state is reset
    944. 

  944.   (setq nmcobol-find-syntactic--state ())
    945. 

  945. ;  (setq font-lock-extend-region-functions
    946. 

  946. ;        (append font-lock-extend-region-functions
    947. 

  947. ;                '(nmcobol-start-of-statement-hook)))
    948. 

  948.   ;; This is where all the font-lock stuff actually gets set up.  Once
    949. 

  949.   ;; font-lock-defaults has it's value, setting font-lock-mode true should
    950. 

  950.   ;; cause all your syntax highlighting dreams to come true.
    951. 

  951.   (setq font-lock-defaults
    952. 

  952.          ;; The first value is all the keyword expressions.
    953. 

  953.        '(nmcobol-font-lock-keywords
    954. 

  954.          ;; keywords-only means no strings or comments get fontified
    955. 

  955.          nil
    956. 

  956.          ;; case-fold (ignore case)
    957. 

  957.          t
    958. 

  958.          ;; syntax-alist.  See also imenu-syntax-alist
    959. 

  959.          ;; This can't override syntax applied by font-lock-syntactic-keywords
    960. 

  960.          ;; It only overrides nmcobol-mode-syntax-table. 
    961. 

  961.          nil
    962. 

  962.          ;; syntax-begin - function to move outside syntactic block
    963. 

  963.          ;; This doesn't work for some reason.  I'm using the hook
    964. 

  964.          ;; font-lock-extend-region-functions for this.
    965. 

  965.          nil ; nmcobol-start-of-statement
    966. 

  966.          ;; font-lock-syntactic-keywords
    967. 

  967.          ;; takes (matcher (match syntax override lexmatch) ...)...
    968. 

  968.          (font-lock-syntactic-keywords . nmcobol-font-lock-syntactic-keywords)))
    969. 

  969.   ; font lock is turned on by default in this mode. Use customize to disable.
    970. 

  970.   (when nmcobol-font-lock-always (font-lo…
    971.

Large files files are truncated, but you can click here to view the full file